@shepai/cli 1.122.1 → 1.122.2-pr367.fdba557

package/dist/packages/core/src/infrastructure/services/webhook/github-webhook.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-webhook.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/webhook/github-webhook.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EACV,eAAe,EACf,YAAY,EACZ,uBAAuB,EACxB,MAAM,yEAAyE,CAAC;AACjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gFAAgF,CAAC;AACzH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wEAAwE,CAAC;AAC5G,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8EAA8E,CAAC;AASzH,MAAM,MAAM,YAAY,GAAG,CACzB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEjD,MAAM,WAAW,iBAAiB;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;AAEpE,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,qBAAqB,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,qBAAa,oBAAqB,YAAW,eAAe;IAC1D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IACjD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAgB;IAC7C,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAuB;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA2B;IAC9D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA+B;IAC/D,OAAO,CAAC,aAAa,CAAS;gBAG5B,WAAW,EAAE,kBAAkB,EAC/B,YAAY,EAAE,aAAa,EAC3B,mBAAmB,EAAE,oBAAoB,EACzC,MAAM,EAAE,YAAY;IAStB;;;OAGG;IACH,SAAS,IAAI,MAAM;IAInB;;OAEG;IACH,qBAAqB,IAAI,SAAS,iBAAiB,EAAE;IAIrD;;OAEG;IACH,kBAAkB,IAAI,SAAS,qBAAqB,EAAE;IAIhD,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBlD,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkC/C,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IA4BrC,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,uBAAuB;IAgCxF,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IA4CrD,OAAO,CAAC,cAAc;YAOR,sBAAsB;YAsBtB,qBAAqB;YAiBrB,mBAAmB;YAoBnB,uBAAuB;YAWvB,mBAAmB;YAKnB,qBAAqB;YA6CrB,qBAAqB;YA4BrB,sBAAsB;YAqDtB,eAAe;CAe9B"}

package/dist/packages/core/src/infrastructure/services/webhook/github-webhook.service.js

@@ -0,0 +1,372 @@
+/**
+ * GitHub Webhook Service
+ *
+ * Manages GitHub webhook registration and incoming event processing.
+ * Uses the GitHub CLI (`gh api`) for webhook CRUD operations.
+ *
+ * Webhook events supplement the existing PR sync polling:
+ * - Webhooks provide near-instant event delivery
+ * - Polling remains as a fallback for missed events
+ *
+ * Registered events: pull_request, check_suite, check_run
+ */
+import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+import { SdlcLifecycle, PrStatus, CiStatus } from '../../../domain/generated/output.js';
+import { NotificationEventType, NotificationSeverity } from '../../../domain/generated/output.js';
+const TAG = '[GitHubWebhook]';
+const WEBHOOK_EVENTS = ['pull_request', 'check_suite', 'check_run'];
+const MAX_EVENT_HISTORY = 200;
+export class GitHubWebhookService {
+    featureRepo;
+    gitPrService;
+    notificationService;
+    execFn;
+    registeredWebhooks = [];
+    deliveryHistory = [];
+    webhookSecret;
+    constructor(featureRepo, gitPrService, notificationService, execFn) {
+        this.featureRepo = featureRepo;
+        this.gitPrService = gitPrService;
+        this.notificationService = notificationService;
+        this.execFn = execFn;
+        this.webhookSecret = randomBytes(32).toString('hex');
+    }
+    /**
+     * Get the webhook secret for signature validation.
+     * Exposed so the API route can validate incoming requests.
+     */
+    getSecret() {
+        return this.webhookSecret;
+    }
+    /**
+     * Get the list of registered webhooks (for dashboard display).
+     */
+    getRegisteredWebhooks() {
+        return this.registeredWebhooks;
+    }
+    /**
+     * Get recent delivery history (newest first).
+     */
+    getDeliveryHistory() {
+        return this.deliveryHistory;
+    }
+    async registerWebhooks(publicUrl) {
+        const webhookUrl = `${publicUrl}/api/webhooks/github`;
+        // Find all repos with features in Review lifecycle
+        const features = await this.featureRepo.list({ lifecycle: SdlcLifecycle.Review });
+        const repoPaths = new Set();
+        for (const feature of features) {
+            if (feature.repositoryPath) {
+                repoPaths.add(feature.repositoryPath);
+            }
+        }
+        for (const repoPath of repoPaths) {
+            await this.registerWebhookForRepo(repoPath, webhookUrl);
+        }
+        // eslint-disable-next-line no-console
+        console.log(`${TAG} Registered webhooks for ${this.registeredWebhooks.length} repositories`);
+    }
+    async updateWebhookUrl(newUrl) {
+        const webhookUrl = `${newUrl}/api/webhooks/github`;
+        for (const webhook of this.registeredWebhooks) {
+            try {
+                await this.execFn('gh', [
+                    'api',
+                    '--method',
+                    'PATCH',
+                    `-H`,
+                    'Accept: application/vnd.github+json',
+                    `/repos/${webhook.repoFullName}/hooks/${webhook.webhookId}`,
+                    '-f',
+                    `config[url]=${webhookUrl}`,
+                    '-f',
+                    `config[content_type]=json`,
+                    '-f',
+                    `config[secret]=${this.webhookSecret}`,
+                ], { cwd: webhook.repositoryPath });
+                // eslint-disable-next-line no-console
+                console.log(`${TAG} Updated webhook URL for ${webhook.repoFullName}`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                // eslint-disable-next-line no-console
+                console.warn(`${TAG} Failed to update webhook for ${webhook.repoFullName}: ${msg}`);
+            }
+        }
+    }
+    async removeWebhooks() {
+        for (const webhook of this.registeredWebhooks) {
+            try {
+                await this.execFn('gh', [
+                    'api',
+                    '--method',
+                    'DELETE',
+                    `-H`,
+                    'Accept: application/vnd.github+json',
+                    `/repos/${webhook.repoFullName}/hooks/${webhook.webhookId}`,
+                ], { cwd: webhook.repositoryPath });
+                // eslint-disable-next-line no-console
+                console.log(`${TAG} Removed webhook for ${webhook.repoFullName}`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                // eslint-disable-next-line no-console
+                console.warn(`${TAG} Failed to remove webhook for ${webhook.repoFullName}: ${msg}`);
+            }
+        }
+        this.registeredWebhooks.length = 0;
+    }
+    validateSignature(payload, signature, secret) {
+        if (!signature) {
+            return { valid: false, error: 'Missing signature header' };
+        }
+        const parts = signature.split('=');
+        if (parts.length !== 2 || parts[0] !== 'sha256') {
+            return { valid: false, error: 'Invalid signature format (expected sha256=...)' };
+        }
+        const expected = createHmac('sha256', secret).update(payload).digest('hex');
+        const actual = parts[1];
+        // Use timing-safe comparison to prevent timing attacks
+        try {
+            const expectedBuf = Buffer.from(expected, 'hex');
+            const actualBuf = Buffer.from(actual, 'hex');
+            if (expectedBuf.length !== actualBuf.length) {
+                return { valid: false, error: 'Signature length mismatch' };
+            }
+            if (!timingSafeEqual(expectedBuf, actualBuf)) {
+                return { valid: false, error: 'Signature mismatch' };
+            }
+            return { valid: true };
+        }
+        catch {
+            return { valid: false, error: 'Invalid signature encoding' };
+        }
+    }
+    async handleEvent(event) {
+        const startTime = Date.now();
+        // eslint-disable-next-line no-console
+        console.log(`${TAG} Received ${event.source}/${event.eventType} (delivery: ${event.deliveryId})`);
+        let status = 'success';
+        let statusMessage = 'Processed successfully';
+        try {
+            switch (event.eventType) {
+                case 'pull_request':
+                    await this.handlePullRequestEvent(event.payload);
+                    break;
+                case 'check_suite':
+                    await this.handleCheckSuiteEvent(event.payload);
+                    break;
+                case 'check_run':
+                    await this.handleCheckRunEvent(event.payload);
+                    break;
+                default:
+                    status = 'ignored';
+                    statusMessage = `Unhandled event type: ${event.eventType}`;
+                    // eslint-disable-next-line no-console
+                    console.log(`${TAG} Ignoring unhandled event type: ${event.eventType}`);
+            }
+        }
+        catch (error) {
+            status = 'error';
+            statusMessage = error instanceof Error ? error.message : String(error);
+        }
+        this.recordDelivery({
+            deliveryId: event.deliveryId,
+            eventType: event.eventType,
+            source: event.source,
+            receivedAt: new Date().toISOString(),
+            status,
+            statusMessage,
+            durationMs: Date.now() - startTime,
+            payload: event.payload,
+        });
+    }
+    recordDelivery(record) {
+        this.deliveryHistory.unshift(record);
+        if (this.deliveryHistory.length > MAX_EVENT_HISTORY) {
+            this.deliveryHistory.length = MAX_EVENT_HISTORY;
+        }
+    }
+    async handlePullRequestEvent(payload) {
+        const action = payload.action;
+        const pr = payload.pull_request;
+        if (!pr)
+            return;
+        const prNumber = pr.number;
+        const prUrl = pr.html_url ?? '';
+        const headBranch = pr.head?.ref;
+        // Find feature by PR number or branch
+        const feature = await this.findFeatureByPrOrBranch(prNumber, headBranch);
+        if (!feature)
+            return;
+        if (action === 'closed' && pr.merged === true) {
+            await this.updateFeaturePrStatus(feature, PrStatus.Merged, prNumber, prUrl);
+        }
+        else if (action === 'closed') {
+            await this.updateFeaturePrStatus(feature, PrStatus.Closed, prNumber, prUrl);
+        }
+        else if (action === 'reopened') {
+            await this.updateFeaturePrStatus(feature, PrStatus.Open, prNumber, prUrl);
+        }
+    }
+    async handleCheckSuiteEvent(payload) {
+        const action = payload.action;
+        if (action !== 'completed')
+            return;
+        const checkSuite = payload.check_suite;
+        if (!checkSuite)
+            return;
+        const conclusion = checkSuite.conclusion;
+        const headBranch = checkSuite.head_branch;
+        const feature = await this.findFeatureByBranch(headBranch);
+        if (!feature)
+            return;
+        const ciStatus = conclusion === 'success' ? CiStatus.Success : CiStatus.Failure;
+        await this.updateFeatureCiStatus(feature, ciStatus);
+    }
+    async handleCheckRunEvent(payload) {
+        const action = payload.action;
+        if (action !== 'completed')
+            return;
+        const checkRun = payload.check_run;
+        if (!checkRun)
+            return;
+        const conclusion = checkRun.conclusion;
+        const checkSuite = checkRun.check_suite;
+        const headBranch = checkSuite?.head_branch;
+        if (!headBranch)
+            return;
+        const feature = await this.findFeatureByBranch(headBranch);
+        if (!feature)
+            return;
+        const ciStatus = conclusion === 'success' ? CiStatus.Success : CiStatus.Failure;
+        await this.updateFeatureCiStatus(feature, ciStatus);
+    }
+    async findFeatureByPrOrBranch(prNumber, branch) {
+        const features = await this.featureRepo.list({ lifecycle: SdlcLifecycle.Review });
+        // Try matching by PR number first
+        const byPr = features.find((f) => f.pr?.number === prNumber);
+        if (byPr)
+            return byPr;
+        // Fall back to branch matching
+        return features.find((f) => f.branch === branch) ?? null;
+    }
+    async findFeatureByBranch(branch) {
+        const features = await this.featureRepo.list({ lifecycle: SdlcLifecycle.Review });
+        return features.find((f) => f.branch === branch) ?? null;
+    }
+    async updateFeaturePrStatus(feature, status, prNumber, prUrl) {
+        const oldStatus = feature.pr?.status;
+        if (oldStatus === status)
+            return;
+        feature.pr = { ...feature.pr, status, url: prUrl, number: prNumber };
+        if (status === PrStatus.Merged) {
+            feature.lifecycle = SdlcLifecycle.Maintain;
+        }
+        await this.featureRepo.update(feature);
+        // Emit notification
+        const eventType = status === PrStatus.Merged
+            ? NotificationEventType.PrMerged
+            : status === PrStatus.Closed
+                ? NotificationEventType.PrClosed
+                : NotificationEventType.PrChecksPassed; // reopened
+        const severity = status === PrStatus.Merged
+            ? NotificationSeverity.Success
+            : status === PrStatus.Closed
+                ? NotificationSeverity.Warning
+                : NotificationSeverity.Info;
+        const event = {
+            eventType,
+            featureId: feature.id,
+            agentRunId: feature.agentRunId ?? '',
+            featureName: feature.name,
+            message: `PR #${prNumber} ${status.toLowerCase()} for ${feature.name} (via webhook)`,
+            severity,
+            timestamp: new Date().toISOString(),
+        };
+        this.notificationService.notify(event);
+    }
+    async updateFeatureCiStatus(feature, ciStatus) {
+        if (!feature.pr)
+            return;
+        if (feature.pr.ciStatus === ciStatus)
+            return;
+        feature.pr = { ...feature.pr, ciStatus };
+        await this.featureRepo.update(feature);
+        const eventType = ciStatus === CiStatus.Success
+            ? NotificationEventType.PrChecksPassed
+            : NotificationEventType.PrChecksFailed;
+        const severity = ciStatus === CiStatus.Success ? NotificationSeverity.Success : NotificationSeverity.Error;
+        const event = {
+            eventType,
+            featureId: feature.id,
+            agentRunId: feature.agentRunId ?? '',
+            featureName: feature.name,
+            message: `CI ${ciStatus === CiStatus.Success ? 'passed' : 'failed'} for ${feature.name} (via webhook)`,
+            severity,
+            timestamp: new Date().toISOString(),
+        };
+        this.notificationService.notify(event);
+    }
+    async registerWebhookForRepo(repoPath, webhookUrl) {
+        try {
+            // Get the repo full name (owner/repo) from the remote URL
+            const repoFullName = await this.getRepoFullName(repoPath);
+            if (!repoFullName) {
+                // eslint-disable-next-line no-console
+                console.warn(`${TAG} Could not determine repo name for ${repoPath}`);
+                return;
+            }
+            // Create webhook via GitHub API
+            const { stdout } = await this.execFn('gh', [
+                'api',
+                '--method',
+                'POST',
+                `-H`,
+                'Accept: application/vnd.github+json',
+                `/repos/${repoFullName}/hooks`,
+                '-f',
+                'name=web',
+                '-f',
+                `config[url]=${webhookUrl}`,
+                '-f',
+                'config[content_type]=json',
+                '-f',
+                `config[secret]=${this.webhookSecret}`,
+                ...WEBHOOK_EVENTS.flatMap((e) => ['-f', `events[]=${e}`]),
+                '-F',
+                'active=true',
+            ], { cwd: repoPath });
+            const response = JSON.parse(stdout);
+            const webhookId = response.id;
+            this.registeredWebhooks.push({
+                repoFullName,
+                webhookId,
+                repositoryPath: repoPath,
+            });
+            // eslint-disable-next-line no-console
+            console.log(`${TAG} Registered webhook #${webhookId} for ${repoFullName}`);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            // eslint-disable-next-line no-console
+            console.warn(`${TAG} Failed to register webhook for ${repoPath}: ${msg}`);
+        }
+    }
+    async getRepoFullName(repoPath) {
+        try {
+            const remoteUrl = await this.gitPrService.getRemoteUrl(repoPath);
+            if (!remoteUrl)
+                return null;
+            // Parse owner/repo from URL
+            // Handles both https://github.com/owner/repo and git@github.com:owner/repo.git
+            const match = remoteUrl.match(/github\.com[/:]([\w.-]+)\/([\w.-]+?)(?:\.git)?$/);
+            if (!match)
+                return null;
+            return `${match[1]}/${match[2]}`;
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/packages/core/src/infrastructure/services/webhook/webhook-manager.service.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Webhook Manager Service
+ *
+ * Orchestrates the Cloudflare Tunnel and GitHub Webhook lifecycle.
+ * Follows the singleton pattern used by NotificationWatcherService
+ * and PrSyncWatcherService.
+ *
+ * Lifecycle:
+ * 1. Start Cloudflare Tunnel to get a public URL
+ * 2. Register GitHub webhooks pointing to the tunnel URL
+ * 3. Monitor for tunnel URL changes → update webhooks
+ * 4. On shutdown → remove webhooks → stop tunnel
+ *
+ * The manager is optional — if cloudflared is not installed or webhook
+ * registration fails, the system falls back to polling gracefully.
+ */
+import type { ITunnelService } from '../../../application/ports/output/services/tunnel-service.interface.js';
+import type { IWebhookService } from '../../../application/ports/output/services/webhook-service.interface.js';
+import type { RegisteredWebhook, WebhookDeliveryRecord } from './github-webhook.service.js';
+export interface WebhookSystemStatus {
+    running: boolean;
+    tunnel: {
+        connected: boolean;
+        publicUrl: string | null;
+    };
+    webhooks: {
+        registered: readonly RegisteredWebhook[];
+        totalDeliveries: number;
+        successCount: number;
+        errorCount: number;
+        ignoredCount: number;
+    };
+    startedAt: string | null;
+}
+export declare class WebhookManagerService {
+    private readonly tunnelService;
+    private readonly webhookService;
+    private running;
+    private startedAt;
+    constructor(tunnelService: ITunnelService, webhookService: IWebhookService);
+    /**
+     * Start the tunnel and register webhooks.
+     * Fails gracefully — logs warnings but does not throw.
+     *
+     * @param localPort - The local web server port to tunnel
+     */
+    start(localPort: number): Promise<void>;
+    /**
+     * Stop the webhook system — remove webhooks, then stop the tunnel.
+     */
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    getTunnelUrl(): string | null;
+    getStatus(): WebhookSystemStatus;
+    getDeliveryHistory(): readonly WebhookDeliveryRecord[];
+}
+/**
+ * Initialize the webhook manager singleton.
+ * Must be called once during web server startup.
+ *
+ * @throws Error if the manager is already initialized
+ */
+export declare function initializeWebhookManager(tunnelService: ITunnelService, webhookService: IWebhookService): void;
+/**
+ * Get the webhook manager singleton.
+ *
+ * @returns The webhook manager service
+ * @throws Error if the manager hasn't been initialized yet
+ */
+export declare function getWebhookManager(): WebhookManagerService;
+/**
+ * Check if the webhook manager has been initialized.
+ */
+export declare function hasWebhookManager(): boolean;
+/**
+ * Reset the webhook manager singleton (for testing purposes only).
+ * Stops the manager if running before resetting.
+ *
+ * @internal
+ */
+export declare function resetWebhookManager(): void;
+//# sourceMappingURL=webhook-manager.service.d.ts.map

package/dist/packages/core/src/infrastructure/services/webhook/webhook-manager.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-manager.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/webhook/webhook-manager.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wEAAwE,CAAC;AAC7G,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yEAAyE,CAAC;AAC/G,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EAEtB,MAAM,6BAA6B,CAAC;AAErC,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE;QACN,SAAS,EAAE,OAAO,CAAC;QACnB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;KAC1B,CAAC;IACF,QAAQ,EAAE;QACR,UAAU,EAAE,SAAS,iBAAiB,EAAE,CAAC;QACzC,eAAe,EAAE,MAAM,CAAC;QACxB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAID,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAiB;IAC/C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAkB;IACjD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAuB;gBAE5B,aAAa,EAAE,cAAc,EAAE,cAAc,EAAE,eAAe;IAK1E;;;;;OAKG;IACG,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA2C7C;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B3B,SAAS,IAAI,OAAO;IAIpB,YAAY,IAAI,MAAM,GAAG,IAAI;IAI7B,SAAS,IAAI,mBAAmB;IAoChC,kBAAkB,IAAI,SAAS,qBAAqB,EAAE;CAOvD;AAoBD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,cAAc,EAC7B,cAAc,EAAE,eAAe,GAC9B,IAAI,CAMN;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,IAAI,qBAAqB,CASzD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAM1C"}

package/dist/packages/core/src/infrastructure/services/webhook/webhook-manager.service.js

@@ -0,0 +1,206 @@
+/**
+ * Webhook Manager Service
+ *
+ * Orchestrates the Cloudflare Tunnel and GitHub Webhook lifecycle.
+ * Follows the singleton pattern used by NotificationWatcherService
+ * and PrSyncWatcherService.
+ *
+ * Lifecycle:
+ * 1. Start Cloudflare Tunnel to get a public URL
+ * 2. Register GitHub webhooks pointing to the tunnel URL
+ * 3. Monitor for tunnel URL changes → update webhooks
+ * 4. On shutdown → remove webhooks → stop tunnel
+ *
+ * The manager is optional — if cloudflared is not installed or webhook
+ * registration fails, the system falls back to polling gracefully.
+ */
+const TAG = '[WebhookManager]';
+export class WebhookManagerService {
+    tunnelService;
+    webhookService;
+    running = false;
+    startedAt = null;
+    constructor(tunnelService, webhookService) {
+        this.tunnelService = tunnelService;
+        this.webhookService = webhookService;
+    }
+    /**
+     * Start the tunnel and register webhooks.
+     * Fails gracefully — logs warnings but does not throw.
+     *
+     * @param localPort - The local web server port to tunnel
+     */
+    async start(localPort) {
+        if (this.running)
+            return;
+        try {
+            // Step 1: Start the tunnel
+            // eslint-disable-next-line no-console
+            console.log(`${TAG} Starting Cloudflare Tunnel for port ${localPort}...`);
+            const publicUrl = await this.tunnelService.start(localPort);
+            // Step 2: Listen for URL changes
+            this.tunnelService.onUrlChange(async (newUrl) => {
+                // eslint-disable-next-line no-console
+                console.log(`${TAG} Tunnel URL changed, updating webhooks...`);
+                try {
+                    await this.webhookService.updateWebhookUrl(newUrl);
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    // eslint-disable-next-line no-console
+                    console.warn(`${TAG} Failed to update webhooks after URL change: ${msg}`);
+                }
+            });
+            // Step 3: Register webhooks with external services
+            await this.webhookService.registerWebhooks(publicUrl);
+            this.running = true;
+            this.startedAt = new Date().toISOString();
+            // eslint-disable-next-line no-console
+            console.log(`${TAG} Webhook system ready (tunnel: ${publicUrl})`);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            // eslint-disable-next-line no-console
+            console.warn(`${TAG} Failed to start webhook system (falling back to polling): ${msg}`);
+            // Clean up partial state
+            try {
+                await this.tunnelService.stop();
+            }
+            catch {
+                // Already stopped or never started
+            }
+        }
+    }
+    /**
+     * Stop the webhook system — remove webhooks, then stop the tunnel.
+     */
+    async stop() {
+        if (!this.running)
+            return;
+        // eslint-disable-next-line no-console
+        console.log(`${TAG} Shutting down webhook system...`);
+        try {
+            await this.webhookService.removeWebhooks();
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            // eslint-disable-next-line no-console
+            console.warn(`${TAG} Failed to remove webhooks during shutdown: ${msg}`);
+        }
+        try {
+            await this.tunnelService.stop();
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            // eslint-disable-next-line no-console
+            console.warn(`${TAG} Failed to stop tunnel during shutdown: ${msg}`);
+        }
+        this.running = false;
+        // eslint-disable-next-line no-console
+        console.log(`${TAG} Webhook system stopped`);
+    }
+    isRunning() {
+        return this.running;
+    }
+    getTunnelUrl() {
+        return this.tunnelService.getPublicUrl();
+    }
+    getStatus() {
+        const ghService = this.webhookService;
+        const deliveries = typeof ghService.getDeliveryHistory === 'function' ? ghService.getDeliveryHistory() : [];
+        const registered = typeof ghService.getRegisteredWebhooks === 'function'
+            ? ghService.getRegisteredWebhooks()
+            : [];
+        let successCount = 0;
+        let errorCount = 0;
+        let ignoredCount = 0;
+        for (const d of deliveries) {
+            if (d.status === 'success')
+                successCount++;
+            else if (d.status === 'error')
+                errorCount++;
+            else
+                ignoredCount++;
+        }
+        return {
+            running: this.running,
+            tunnel: {
+                connected: this.tunnelService.isRunning(),
+                publicUrl: this.tunnelService.getPublicUrl(),
+            },
+            webhooks: {
+                registered,
+                totalDeliveries: deliveries.length,
+                successCount,
+                errorCount,
+                ignoredCount,
+            },
+            startedAt: this.startedAt,
+        };
+    }
+    getDeliveryHistory() {
+        const ghService = this.webhookService;
+        if (typeof ghService.getDeliveryHistory === 'function') {
+            return ghService.getDeliveryHistory();
+        }
+        return [];
+    }
+}
+// --- Singleton accessors ---
+//
+// The singleton is stored on globalThis so that it survives module duplication
+// across bundler contexts (e.g. Next.js Turbopack bundles API routes separately
+// from the dev-server entry point, giving each its own copy of module-level
+// variables). By using globalThis, the same manager instance is visible to both
+// the initializer (dev-server.ts / CLI) and the API route handlers.
+const GLOBAL_KEY = '__shepWebhookManager';
+function getInstance() {
+    return globalThis[GLOBAL_KEY] ?? null;
+}
+function setInstance(instance) {
+    globalThis[GLOBAL_KEY] = instance;
+}
+/**
+ * Initialize the webhook manager singleton.
+ * Must be called once during web server startup.
+ *
+ * @throws Error if the manager is already initialized
+ */
+export function initializeWebhookManager(tunnelService, webhookService) {
+    if (getInstance() !== null) {
+        throw new Error('Webhook manager already initialized. Cannot re-initialize.');
+    }
+    setInstance(new WebhookManagerService(tunnelService, webhookService));
+}
+/**
+ * Get the webhook manager singleton.
+ *
+ * @returns The webhook manager service
+ * @throws Error if the manager hasn't been initialized yet
+ */
+export function getWebhookManager() {
+    const instance = getInstance();
+    if (instance === null) {
+        throw new Error('Webhook manager not initialized. Call initializeWebhookManager() during web server startup.');
+    }
+    return instance;
+}
+/**
+ * Check if the webhook manager has been initialized.
+ */
+export function hasWebhookManager() {
+    return getInstance() !== null;
+}
+/**
+ * Reset the webhook manager singleton (for testing purposes only).
+ * Stops the manager if running before resetting.
+ *
+ * @internal
+ */
+export function resetWebhookManager() {
+    const instance = getInstance();
+    if (instance !== null) {
+        void instance.stop();
+    }
+    setInstance(null);
+}

package/dist/src/presentation/cli/commands/ui.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ui.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/ui.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AAgC1D;;GAEG;AACH,wBAAgB,eAAe,IAAI,OAAO,CA0FzC"}
+{"version":3,"file":"ui.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/ui.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AAuC1D;;GAEG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAwGzC"}