Register webhook and script in create PR command

packages/host/app/commands/create-listing-pr.ts

@@ -187,7 +187,24 @@ export default class CreateListingPRCommand extends HostBaseCommand<
 
     log.debug('PR created successfully:', prResult);
 
-    // Open room and send PR status message with full details
+    // Register webhook for PR status updates
+    const webhookData = await this.registerPRWebhook(prResult.prNumber);
+
+    if (webhookData) {
+      manifest.webhook = {
+        id: webhookData.id,
+        path: webhookData.path,
+        signingSecret: webhookData.signingSecret,
+      };
+
+      log.debug('Webhook registered for PR:', {
+        webhookUrl: `${this.realmServer.url.href}_webhooks/${webhookData.path}`,
+        signingSecret: webhookData.signingSecret,
+        prNumber: prResult.prNumber,
+      });
+    }
+
+    // Open room and send PR status message
     await new UseAiAssistantCommand(this.commandContext).execute({
       roomId,
       prompt: `I just submitted a PR for my listing "${listing.name ?? listing.id}".
@@ -208,6 +225,47 @@ PR Details:
     return await this.makeResult(manifest);
   }
 
+  private async registerPRWebhook(
+    prNumber: number,
+  ): Promise<{ id: string; path: string; signingSecret: string } | null> {
+    try {
+      const webhook = await this.realmServer.createIncomingWebhook({
+        verificationType: 'HMAC_SHA256_HEADER',
+        verificationConfig: {
+          header: 'x-hub-signature-256',
+          encoding: 'hex',
+        },
+      });
+
+      log.debug('Created incoming webhook:', {
+        id: webhook.id,
+        path: webhook.webhookPath,
+      });
+
+      await this.realmServer.createWebhookCommand({
+        incomingWebhookId: webhook.id,
+        command: `${this.realmServer.url.href}catalog-realm/commands/process-github-webhook`,
+        filter: {
+          eventType: 'pull_request',
+          prNumber: prNumber,
+        },
+      });
+
+      log.debug('Registered webhook command for PR', { prNumber });
+
+      return {
+        id: webhook.id,
+        path: webhook.webhookPath,
+        signingSecret: webhook.signingSecret,
+      };
+    } catch (error: any) {
+      log.error('Failed to register PR webhook:', error);
+      // Don't fail the entire PR creation if webhook registration fails
+      // Just log and continue
+      return null;
+    }
+  }
+
   private async collectAndFetchFiles(
     listing: Listing,
     plan: ReturnType<PlanBuilder['build']>,

packages/host/app/services/realm-server.ts

@@ -1022,6 +1022,130 @@ export default class RealmServerService extends Service {
     return data.attributes;
   }
 
+  async createIncomingWebhook(params: {
+    verificationType: 'HMAC_SHA256_HEADER';
+    verificationConfig: {
+      header: string;
+      encoding: 'hex' | 'base64';
+    };
+  }): Promise<{
+    id: string;
+    webhookPath: string;
+    signingSecret: string;
+    username: string;
+    createdAt: string;
+  }> {
+    await this.login();
+
+    const response = await this.authedFetch(
+      `${this.url.href}_incoming-webhooks`,
+      {
+        method: 'POST',
+        headers: {
+          Accept: SupportedMimeType.JSONAPI,
+          'Content-Type': 'application/vnd.api+json',
+        },
+        body: JSON.stringify({
+          data: {
+            type: 'incoming-webhook',
+            attributes: params,
+          },
+        }),
+      },
+    );
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Failed to create incoming webhook: ${response.status} - ${errorText}`,
+      );
+    }
+
+    const { data } = (await response.json()) as {
+      data: {
+        type: string;
+        id: string;
+        attributes: {
+          username: string;
+          webhookPath: string;
+          verificationType: string;
+          verificationConfig: Record<string, unknown>;
+          signingSecret: string;
+          createdAt: string;
+          updatedAt: string;
+        };
+      };
+    };
+
+    return {
+      id: data.id,
+      webhookPath: data.attributes.webhookPath,
+      signingSecret: data.attributes.signingSecret,
+      username: data.attributes.username,
+      createdAt: data.attributes.createdAt,
+    };
+  }
+
+  async createWebhookCommand(params: {
+    incomingWebhookId: string;
+    command: string;
+    filter?: Record<string, unknown> | null;
+  }): Promise<{
+    id: string;
+    incomingWebhookId: string;
+    command: string;
+    filter: Record<string, unknown> | null;
+    createdAt: string;
+  }> {
+    await this.login();
+
+    const response = await this.authedFetch(
+      `${this.url.href}_webhook-commands`,
+      {
+        method: 'POST',
+        headers: {
+          Accept: SupportedMimeType.JSONAPI,
+          'Content-Type': 'application/vnd.api+json',
+        },
+        body: JSON.stringify({
+          data: {
+            type: 'webhook-command',
+            attributes: params,
+          },
+        }),
+      },
+    );
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Failed to create webhook command: ${response.status} - ${errorText}`,
+      );
+    }
+
+    const { data } = (await response.json()) as {
+      data: {
+        type: string;
+        id: string;
+        attributes: {
+          incomingWebhookId: string;
+          command: string;
+          filter: Record<string, unknown> | null;
+          createdAt: string;
+          updatedAt: string;
+        };
+      };
+    };
+
+    return {
+      id: data.id,
+      incomingWebhookId: data.attributes.incomingWebhookId,
+      command: data.attributes.command,
+      filter: data.attributes.filter,
+      createdAt: data.attributes.createdAt,
+    };
+  }
+
   private async getToken() {
     if (!this.token) {
       await this.login();