@shepai/cli 1.116.0 → 1.116.1-pr369.ea52340

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

@@ -0,0 +1,208 @@
+import http from 'node:http';
+import { spawn } from 'node:child_process';
+import { SdlcLifecycle } from '../../../domain/generated/output.js';
+import { findAvailablePort } from '../port.service.js';
+import { getOrCreateGitHubWebhookSecret } from './webhook-secret.service.js';
+const DEFAULT_GATEWAY_PORT = 4590;
+const DEFAULT_RECONCILE_INTERVAL_MS = 60_000;
+const TUNNEL_READY_TIMEOUT_MS = 15_000;
+const GITHUB_WEBHOOK_CALLBACK_PATH = '/api/webhooks/github?source=shep';
+const ENABLE_ENV = 'SHEP_ENABLE_GITHUB_WEBHOOKS';
+const defaultDeps = {
+    createServer: http.createServer,
+    spawnProcess: spawn,
+    findAvailablePort,
+    fetchImpl: fetch,
+    getSecret: getOrCreateGitHubWebhookSecret,
+    logInfo: (message) => process.stdout.write(`${message}\n`),
+    logWarn: (message) => process.stderr.write(`${message}\n`),
+};
+export function isGitHubWebhookRuntimeEnabled() {
+    return process.env[ENABLE_ENV] === '1' || process.env[ENABLE_ENV] === 'true';
+}
+export class GitHubWebhookRuntimeService {
+    featureRepo;
+    webhookService;
+    appPort;
+    reconcileIntervalMs;
+    deps;
+    gatewayServer = null;
+    tunnelProcess = null;
+    reconcileTimer = null;
+    publicBaseUrl = null;
+    gatewayPort = null;
+    secret = null;
+    constructor(featureRepo, webhookService, appPort, reconcileIntervalMs = DEFAULT_RECONCILE_INTERVAL_MS, deps = {}) {
+        this.featureRepo = featureRepo;
+        this.webhookService = webhookService;
+        this.appPort = appPort;
+        this.reconcileIntervalMs = reconcileIntervalMs;
+        this.deps = { ...defaultDeps, ...deps };
+    }
+    getPublicBaseUrl() {
+        return this.publicBaseUrl;
+    }
+    getGatewayPort() {
+        return this.gatewayPort;
+    }
+    async start() {
+        if (!isGitHubWebhookRuntimeEnabled()) {
+            return null;
+        }
+        if (this.publicBaseUrl) {
+            return this.publicBaseUrl;
+        }
+        this.secret = this.deps.getSecret();
+        try {
+            this.gatewayPort = await this.deps.findAvailablePort(DEFAULT_GATEWAY_PORT);
+            await this.startGateway();
+            this.publicBaseUrl = await this.startTunnel();
+            await this.reconcileHooks();
+            this.reconcileTimer = setInterval(() => {
+                void this.reconcileHooks();
+            }, this.reconcileIntervalMs);
+            this.reconcileTimer.unref?.();
+            return this.publicBaseUrl;
+        }
+        catch (error) {
+            await this.stop();
+            throw error;
+        }
+    }
+    async stop() {
+        if (this.reconcileTimer) {
+            clearInterval(this.reconcileTimer);
+            this.reconcileTimer = null;
+        }
+        if (this.tunnelProcess) {
+            this.tunnelProcess.kill('SIGTERM');
+            this.tunnelProcess = null;
+        }
+        if (this.gatewayServer) {
+            await new Promise((resolve) => {
+                this.gatewayServer.close(() => resolve());
+            });
+            this.gatewayServer = null;
+        }
+        this.publicBaseUrl = null;
+        this.gatewayPort = null;
+    }
+    async startGateway() {
+        const port = this.gatewayPort;
+        if (!port) {
+            throw new Error('Gateway port not allocated');
+        }
+        const server = this.deps.createServer((req, res) => {
+            void this.handleGatewayRequest(req, res);
+        });
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(port, '127.0.0.1', () => resolve());
+        });
+        this.gatewayServer = server;
+    }
+    async handleGatewayRequest(req, res) {
+        if (!req.url?.startsWith('/api/webhooks/')) {
+            res.statusCode = 404;
+            res.end('Not found');
+            return;
+        }
+        const body = await this.readRequestBody(req);
+        const headers = new Headers();
+        for (const [key, value] of Object.entries(req.headers)) {
+            if (!value)
+                continue;
+            if (key === 'host' || key === 'connection' || key === 'content-length')
+                continue;
+            if (Array.isArray(value)) {
+                for (const item of value)
+                    headers.append(key, item);
+            }
+            else {
+                headers.set(key, value);
+            }
+        }
+        const requestBody = this.requestCanHaveBody(req.method) ? new Uint8Array(body) : undefined;
+        const response = await this.deps.fetchImpl(`http://127.0.0.1:${this.appPort}${req.url}`, {
+            method: req.method,
+            headers,
+            body: requestBody,
+        });
+        res.statusCode = response.status;
+        response.headers.forEach((value, key) => {
+            res.setHeader(key, value);
+        });
+        const buffer = Buffer.from(await response.arrayBuffer());
+        res.end(buffer);
+    }
+    requestCanHaveBody(method) {
+        return method !== undefined && method !== 'GET' && method !== 'HEAD';
+    }
+    async readRequestBody(req) {
+        const chunks = [];
+        for await (const chunk of req) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        return Buffer.concat(chunks);
+    }
+    async startTunnel() {
+        const port = this.gatewayPort;
+        if (!port) {
+            throw new Error('Gateway port not allocated');
+        }
+        const child = this.deps.spawnProcess(process.env.SHEP_CLOUDFLARED_BIN ?? 'cloudflared', ['tunnel', '--url', `http://127.0.0.1:${port}`], { stdio: ['ignore', 'pipe', 'pipe'] });
+        this.tunnelProcess = child;
+        const publicUrl = await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                cleanup();
+                reject(new Error('Timed out waiting for cloudflared public URL'));
+            }, TUNNEL_READY_TIMEOUT_MS);
+            const onData = (chunk) => {
+                const match = String(chunk).match(/https:\/\/[a-zA-Z0-9.-]+\.trycloudflare\.com/);
+                if (!match)
+                    return;
+                cleanup();
+                resolve(match[0]);
+            };
+            const onExit = (code) => {
+                cleanup();
+                reject(new Error(`cloudflared exited before URL was ready (code ${code ?? 'unknown'})`));
+            };
+            const cleanup = () => {
+                clearTimeout(timeout);
+                child.stdout?.off('data', onData);
+                child.stderr?.off('data', onData);
+                child.off('exit', onExit);
+            };
+            child.stdout?.on('data', onData);
+            child.stderr?.on('data', onData);
+            child.on('exit', onExit);
+        });
+        this.deps.logInfo(`[GitHubWebhookRuntime] Tunnel ready at ${publicUrl}`);
+        return publicUrl;
+    }
+    async reconcileHooks() {
+        if (!this.publicBaseUrl || !this.secret)
+            return;
+        const features = await this.featureRepo.list({ lifecycle: SdlcLifecycle.Review });
+        const repoPaths = [
+            ...new Set(features.map((feature) => feature.repositoryPath).filter(Boolean)),
+        ];
+        for (const repoPath of repoPaths) {
+            try {
+                const result = await this.webhookService.ensureRepositoryWebhook(repoPath, {
+                    callbackUrl: `${this.publicBaseUrl}${GITHUB_WEBHOOK_CALLBACK_PATH}`,
+                    secret: this.secret,
+                    events: ['pull_request', 'check_suite'],
+                });
+                if (result.action !== 'unchanged' && result.action !== 'skipped') {
+                    this.deps.logInfo(`[GitHubWebhookRuntime] ${result.action} webhook for ${repoPath} -> ${result.callbackUrl ?? 'n/a'}`);
+                }
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                this.deps.logWarn(`[GitHubWebhookRuntime] Failed to reconcile ${repoPath}: ${msg}`);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+import type { ExecFunction } from '../git/worktree.service.js';
+import type { IGitPrService } from '../../../application/ports/output/services/git-pr-service.interface.js';
+export interface GitHubWebhookConfig {
+    callbackUrl: string;
+    secret: string;
+    events: string[];
+}
+export interface GitHubWebhookSyncResult {
+    action: 'created' | 'updated' | 'unchanged' | 'skipped';
+    hookId?: number;
+    callbackUrl?: string;
+}
+declare const SHEP_WEBHOOK_MARKER = "source=shep";
+export declare class GitHubWebhookService {
+    private readonly execFile;
+    private readonly gitPrService;
+    constructor(execFile: ExecFunction, gitPrService: Pick<IGitPrService, 'getRemoteUrl'>);
+    ensureRepositoryWebhook(cwd: string, config: GitHubWebhookConfig): Promise<GitHubWebhookSyncResult>;
+    private listHooks;
+    private buildMutationArgs;
+    private isHookUpToDate;
+    private parseHookPayload;
+}
+export { SHEP_WEBHOOK_MARKER };
+//# sourceMappingURL=github-webhook.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"github-webhook.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/webhooks/github-webhook.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qEAAqE,CAAC;AAEzG,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,CAAC;IACxD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAYD,QAAA,MAAM,mBAAmB,gBAAgB,CAAC;AAkB1C,qBAAa,oBAAoB;IAE7B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,YAAY;gBADZ,QAAQ,EAAE,YAAY,EACtB,YAAY,EAAE,IAAI,CAAC,aAAa,EAAE,cAAc,CAAC;IAG9D,uBAAuB,CAC3B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,uBAAuB,CAAC;YAmDrB,SAAS;IAKvB,OAAO,CAAC,iBAAiB;IAuBzB,OAAO,CAAC,cAAc;IAatB,OAAO,CAAC,gBAAgB;CAIzB;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

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

@@ -0,0 +1,99 @@
+const SHEP_WEBHOOK_MARKER = 'source=shep';
+function parseGitHubOwnerRepo(remoteUrl) {
+    if (!remoteUrl)
+        return null;
+    const httpsMatch = remoteUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (httpsMatch) {
+        return { owner: httpsMatch[1], repo: httpsMatch[2] };
+    }
+    const sshMatch = remoteUrl.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (sshMatch) {
+        return { owner: sshMatch[1], repo: sshMatch[2] };
+    }
+    return null;
+}
+export class GitHubWebhookService {
+    execFile;
+    gitPrService;
+    constructor(execFile, gitPrService) {
+        this.execFile = execFile;
+        this.gitPrService = gitPrService;
+    }
+    async ensureRepositoryWebhook(cwd, config) {
+        const remoteUrl = await this.gitPrService.getRemoteUrl(cwd);
+        const repo = parseGitHubOwnerRepo(remoteUrl);
+        if (!repo) {
+            return { action: 'skipped' };
+        }
+        const hooksPath = `repos/${repo.owner}/${repo.repo}/hooks`;
+        const hooks = await this.listHooks(cwd, hooksPath);
+        const existing = hooks.find((hook) => hook.config?.url?.includes(SHEP_WEBHOOK_MARKER));
+        if (!existing) {
+            const created = await this.execFile('gh', ['api', hooksPath, '--method', 'POST', ...this.buildMutationArgs(config)], { cwd });
+            const payload = this.parseHookPayload(created.stdout);
+            return {
+                action: 'created',
+                hookId: payload?.id,
+                callbackUrl: config.callbackUrl,
+            };
+        }
+        if (this.isHookUpToDate(existing, config)) {
+            return {
+                action: 'unchanged',
+                hookId: existing.id,
+                callbackUrl: config.callbackUrl,
+            };
+        }
+        await this.execFile('gh', [
+            'api',
+            `${hooksPath}/${existing.id}`,
+            '--method',
+            'PATCH',
+            ...this.buildMutationArgs(config),
+        ], { cwd });
+        return {
+            action: 'updated',
+            hookId: existing.id,
+            callbackUrl: config.callbackUrl,
+        };
+    }
+    async listHooks(cwd, hooksPath) {
+        const result = await this.execFile('gh', ['api', hooksPath], { cwd });
+        return JSON.parse(result.stdout) ?? [];
+    }
+    buildMutationArgs(config) {
+        const args = [
+            '-f',
+            'name=web',
+            '-f',
+            'active=true',
+            '-f',
+            `config[url]=${config.callbackUrl}`,
+            '-f',
+            'config[content_type]=json',
+            '-f',
+            `config[secret]=${config.secret}`,
+            '-f',
+            'config[insecure_ssl]=0',
+        ];
+        for (const event of config.events) {
+            args.push('-f', `events[]=${event}`);
+        }
+        return args;
+    }
+    isHookUpToDate(hook, config) {
+        const actualEvents = [...(hook.events ?? [])].sort();
+        const desiredEvents = [...config.events].sort();
+        return (hook.active === true &&
+            hook.config?.url === config.callbackUrl &&
+            hook.config?.content_type === 'json' &&
+            actualEvents.length === desiredEvents.length &&
+            actualEvents.every((event, index) => event === desiredEvents[index]));
+    }
+    parseHookPayload(stdout) {
+        if (!stdout.trim())
+            return null;
+        return JSON.parse(stdout);
+    }
+}
+export { SHEP_WEBHOOK_MARKER };

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

@@ -0,0 +1,3 @@
+export declare function getGitHubWebhookSecretPath(): string;
+export declare function getOrCreateGitHubWebhookSecret(): string;
+//# sourceMappingURL=webhook-secret.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-secret.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/webhooks/webhook-secret.service.ts"],"names":[],"mappings":"AAQA,wBAAgB,0BAA0B,IAAI,MAAM,CAEnD;AAED,wBAAgB,8BAA8B,IAAI,MAAM,CAUvD"}

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

@@ -0,0 +1,19 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { getShepHomeDir } from '../filesystem/shep-directory.service.js';
+const WEBHOOK_SECRET_DIR = 'webhooks';
+const GITHUB_SECRET_FILE = 'github.secret';
+export function getGitHubWebhookSecretPath() {
+    return join(getShepHomeDir(), WEBHOOK_SECRET_DIR, GITHUB_SECRET_FILE);
+}
+export function getOrCreateGitHubWebhookSecret() {
+    const secretPath = getGitHubWebhookSecretPath();
+    if (existsSync(secretPath)) {
+        return readFileSync(secretPath, 'utf8').trim();
+    }
+    mkdirSync(join(getShepHomeDir(), WEBHOOK_SECRET_DIR), { recursive: true });
+    const secret = randomBytes(32).toString('hex');
+    writeFileSync(secretPath, `${secret}\n`, { mode: 0o600 });
+    return secret;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"_serve.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/_serve.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AAwB1D;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CA0D5C"}
+{"version":3,"file":"_serve.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/_serve.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AAoC1D;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAqF5C"}

package/dist/src/presentation/cli/commands/_serve.command.js

@@ -29,6 +29,10 @@ import { container } from '../../../../packages/core/src/infrastructure/di/conta
 import { setVersionEnvVars } from '../../../../packages/core/src/infrastructure/services/version.service.js';
 import { resolveWebDir } from '../../../../packages/core/src/infrastructure/services/web-server.service.js';
 import { initializeNotificationWatcher, getNotificationWatcher, } from '../../../../packages/core/src/infrastructure/services/notifications/notification-watcher.service.js';
+import { initializePrSyncWatcher, getPrSyncWatcher, } from '../../../../packages/core/src/infrastructure/services/pr-sync/pr-sync-watcher.service.js';
+import { getExistingConnection } from '../../../../packages/core/src/infrastructure/persistence/sqlite/connection.js';
+import { GitHubWebhookRuntimeService, isGitHubWebhookRuntimeEnabled, } from '../../../../packages/core/src/infrastructure/services/webhooks/github-webhook-runtime.service.js';
+import { GitHubWebhookService } from '../../../../packages/core/src/infrastructure/services/webhooks/github-webhook.service.js';
 function parsePort(value) {
     const port = parseInt(value, 10);
     if (isNaN(port) || port < 1024 || port > 65535) {
@@ -62,6 +66,23 @@ export function createServeCommand() {
             const notificationService = container.resolve('INotificationService');
             initializeNotificationWatcher(runRepo, phaseTimingRepo, featureRepo, notificationService);
             getNotificationWatcher().start();
+            const gitPrService = container.resolve('IGitPrService');
+            const db = getExistingConnection();
+            initializePrSyncWatcher(featureRepo, runRepo, gitPrService, notificationService, undefined, db);
+            getPrSyncWatcher().start();
+            let webhookRuntime = null;
+            if (isGitHubWebhookRuntimeEnabled()) {
+                try {
+                    const execFile = container.resolve('ExecFunction');
+                    const webhookService = new GitHubWebhookService(execFile, gitPrService);
+                    webhookRuntime = new GitHubWebhookRuntimeService(featureRepo, webhookService, port);
+                    await webhookRuntime.start();
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    process.stderr.write(`[_serve] GitHub webhook runtime disabled: ${err.message}\n`);
+                }
+            }
             // Graceful shutdown handler — identical pattern to ui.command.ts
             let isShuttingDown = false;
             const shutdown = async () => {
@@ -71,6 +92,8 @@ export function createServeCommand() {
                 // Force exit after 5s if graceful shutdown stalls
                 const forceExit = setTimeout(() => process.exit(0), 5000);
                 forceExit.unref();
+                await webhookRuntime?.stop();
+                getPrSyncWatcher().stop();
                 getNotificationWatcher().stop();
                 const deploymentService = container.resolve('IDeploymentService');
                 deploymentService.stopAll();

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;AAsC1D;;GAEG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAwGzC"}

package/dist/src/presentation/cli/commands/ui.command.js

@@ -23,6 +23,8 @@ import { initializeNotificationWatcher, getNotificationWatcher, } from '../../..
 import { initializePrSyncWatcher, getPrSyncWatcher, } from '../../../../packages/core/src/infrastructure/services/pr-sync/pr-sync-watcher.service.js';
 import { getExistingConnection } from '../../../../packages/core/src/infrastructure/persistence/sqlite/connection.js';
 import { BrowserOpenerService } from '../../../../packages/core/src/infrastructure/services/browser-opener.service.js';
+import { GitHubWebhookRuntimeService, isGitHubWebhookRuntimeEnabled, } from '../../../../packages/core/src/infrastructure/services/webhooks/github-webhook-runtime.service.js';
+import { GitHubWebhookService } from '../../../../packages/core/src/infrastructure/services/webhooks/github-webhook.service.js';
 import { colors, fmt, messages } from '../ui/index.js';
 function parsePort(value) {
     const port = parseInt(value, 10);
@@ -70,6 +72,19 @@ Examples:
             const db = getExistingConnection();
             initializePrSyncWatcher(featureRepo, runRepo, gitPrService, notificationService, undefined, db);
             getPrSyncWatcher().start();
+            let webhookRuntime = null;
+            if (isGitHubWebhookRuntimeEnabled()) {
+                try {
+                    const execFile = container.resolve('ExecFunction');
+                    const webhookService = new GitHubWebhookService(execFile, gitPrService);
+                    webhookRuntime = new GitHubWebhookRuntimeService(featureRepo, webhookService, port);
+                    await webhookRuntime.start();
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    messages.warning(`GitHub webhook runtime disabled: ${err.message}`);
+                }
+            }
             const url = `http://localhost:${port}`;
             messages.success(`Server ready at ${fmt.code(url)}`);
             messages.info('Press Ctrl+C to stop');
@@ -91,6 +106,7 @@ Examples:
                 // Force exit after 5s if graceful shutdown stalls
                 const forceExit = setTimeout(() => process.exit(0), 5000);
                 forceExit.unref();
+                await webhookRuntime?.stop();
                 getPrSyncWatcher().stop();
                 getNotificationWatcher().stop();
                 await service.stop();

package/dist/src/presentation/web/app/api/webhooks/github/route.d.ts

@@ -0,0 +1,3 @@
+export declare const dynamic = "force-dynamic";
+export declare function POST(request: Request): Promise<Response>;
+//# sourceMappingURL=route.d.ts.map

package/dist/src/presentation/web/app/api/webhooks/github/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../../src/presentation/web/app/api/webhooks/github/route.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAiBvC,wBAAsB,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CA2B9D"}

package/dist/src/presentation/web/app/api/webhooks/github/route.js

@@ -0,0 +1,38 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import { getPrSyncWatcher, hasPrSyncWatcher, } from '../../../../../../../packages/core/src/infrastructure/services/pr-sync/pr-sync-watcher.service.js';
+import { getOrCreateGitHubWebhookSecret } from '../../../../../../../packages/core/src/infrastructure/services/webhooks/webhook-secret.service.js';
+export const dynamic = 'force-dynamic';
+function isValidSignature(rawBody, signatureHeader, secret) {
+    if (!signatureHeader?.startsWith('sha256='))
+        return false;
+    const digest = createHmac('sha256', secret).update(rawBody).digest('hex');
+    const expected = Buffer.from(`sha256=${digest}`);
+    const received = Buffer.from(signatureHeader);
+    if (expected.length !== received.length)
+        return false;
+    return timingSafeEqual(expected, received);
+}
+export async function POST(request) {
+    const rawBody = await request.text();
+    const secret = getOrCreateGitHubWebhookSecret();
+    const signature = request.headers.get('x-hub-signature-256');
+    if (!isValidSignature(rawBody, signature, secret)) {
+        return Response.json({ error: 'Invalid GitHub webhook signature' }, { status: 401 });
+    }
+    let payload;
+    try {
+        payload = JSON.parse(rawBody);
+    }
+    catch {
+        return Response.json({ error: 'Invalid JSON payload' }, { status: 400 });
+    }
+    const fullName = payload.repository?.full_name;
+    if (!fullName) {
+        return Response.json({ error: 'Missing repository.full_name' }, { status: 400 });
+    }
+    if (!hasPrSyncWatcher()) {
+        return Response.json({ accepted: true, refreshed: false }, { status: 202 });
+    }
+    const refreshed = await getPrSyncWatcher().syncRepositoryByGitHubFullName(fullName);
+    return Response.json({ accepted: true, refreshed }, { status: 202 });
+}

package/dist/src/presentation/web/dev-server.js

@@ -20,6 +20,8 @@ import { initializeSettings } from '../../../packages/core/src/infrastructure/se
 import { initializeNotificationWatcher, getNotificationWatcher, } from '../../../packages/core/src/infrastructure/services/notifications/notification-watcher.service.js';
 import { initializePrSyncWatcher, getPrSyncWatcher, } from '../../../packages/core/src/infrastructure/services/pr-sync/pr-sync-watcher.service.js';
 import { getExistingConnection } from '../../../packages/core/src/infrastructure/persistence/sqlite/connection.js';
+import { GitHubWebhookRuntimeService, isGitHubWebhookRuntimeEnabled, } from '../../../packages/core/src/infrastructure/services/webhooks/github-webhook-runtime.service.js';
+import { GitHubWebhookService } from '../../../packages/core/src/infrastructure/services/webhooks/github-webhook.service.js';
 const DEFAULT_PORT = 3000;
 async function isPortAvailable(port) {
     return new Promise((resolve) => {
@@ -68,6 +70,19 @@ async function main() {
         const db = getExistingConnection();
         initializePrSyncWatcher(featureRepo, runRepo, gitPrService, notificationService, undefined, db);
         getPrSyncWatcher().start();
+        let webhookRuntime = null;
+        if (isGitHubWebhookRuntimeEnabled()) {
+            try {
+                const execFile = container.resolve('ExecFunction');
+                const webhookService = new GitHubWebhookService(execFile, gitPrService);
+                webhookRuntime = new GitHubWebhookRuntimeService(featureRepo, webhookService, port);
+                await webhookRuntime.start();
+            }
+            catch (error) {
+                console.warn('[dev-server] GitHub webhook runtime disabled:', error);
+            }
+        }
+        globalThis.__shepGithubWebhookRuntime = webhookRuntime;
     }
     catch (error) {
         console.warn('[dev-server] DI initialization failed — features will be empty:', error);
@@ -107,6 +122,14 @@ async function main() {
         console.log('\n[dev-server] Shutting down...');
         const forceExit = setTimeout(() => process.exit(0), 2000);
         try {
+            try {
+                const webhookRuntime = globalThis
+                    .__shepGithubWebhookRuntime;
+                await webhookRuntime?.stop();
+            }
+            catch {
+                /* runtime not initialized */
+            }
             try {
                 getNotificationWatcher().stop();
             }