patchrelay 0.8.8 → 0.9.0

package/dist/webhook-handler.js

@@ -0,0 +1,387 @@
+import { buildPreparingSessionPlan, buildRunningSessionPlan, } from "./agent-session-plan.js";
+import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
+import { resolveProject, triggerEventAllowed, trustedActorAllowed } from "./project-resolution.js";
+import { normalizeWebhook } from "./webhooks.js";
+import { InstallationWebhookHandler } from "./webhook-installation-handler.js";
+import { safeJsonParse, sanitizeDiagnosticText } from "./utils.js";
+export class WebhookHandler {
+    config;
+    db;
+    linearProvider;
+    codex;
+    enqueueIssue;
+    logger;
+    feed;
+    installationHandler;
+    constructor(config, db, linearProvider, codex, enqueueIssue, logger, feed) {
+        this.config = config;
+        this.db = db;
+        this.linearProvider = linearProvider;
+        this.codex = codex;
+        this.enqueueIssue = enqueueIssue;
+        this.logger = logger;
+        this.feed = feed;
+        this.installationHandler = new InstallationWebhookHandler(config, { linearInstallations: db.linearInstallations }, logger);
+    }
+    async processWebhookEvent(webhookEventId) {
+        const event = this.db.getWebhookPayload(webhookEventId);
+        if (!event) {
+            this.logger.warn({ webhookEventId }, "Webhook event was not found during processing");
+            return;
+        }
+        try {
+            const payload = safeJsonParse(event.payloadJson);
+            if (!payload) {
+                this.db.markWebhookProcessed(webhookEventId, "failed");
+                throw new Error(`Stored webhook payload is invalid JSON: event ${webhookEventId}`);
+            }
+            let normalized = normalizeWebhook({ webhookId: event.webhookId, payload });
+            this.logger.info({
+                webhookEventId,
+                webhookId: event.webhookId,
+                triggerEvent: normalized.triggerEvent,
+                issueKey: normalized.issue?.identifier,
+            }, "Processing stored webhook event");
+            if (!normalized.issue) {
+                this.feed?.publish({
+                    level: "info",
+                    kind: "webhook",
+                    status: normalized.triggerEvent,
+                    summary: `Received ${normalized.triggerEvent} webhook`,
+                });
+                this.installationHandler.handle(normalized);
+                this.db.markWebhookProcessed(webhookEventId, "processed");
+                return;
+            }
+            let project = resolveProject(this.config, normalized.issue);
+            if (!project) {
+                const routed = await this.tryHydrateProjectRoute(normalized);
+                if (routed) {
+                    normalized = routed.normalized;
+                    project = routed.project;
+                }
+            }
+            if (!project) {
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "webhook",
+                    issueKey: normalized.issue?.identifier,
+                    status: "ignored",
+                    summary: "Ignored webhook with no matching project route",
+                });
+                this.db.markWebhookProcessed(webhookEventId, "processed");
+                return;
+            }
+            const routedIssue = normalized.issue;
+            if (!routedIssue) {
+                this.db.markWebhookProcessed(webhookEventId, "failed");
+                throw new Error(`Issue context disappeared while routing webhook ${event.webhookId}`);
+            }
+            if (!trustedActorAllowed(project, normalized.actor)) {
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "webhook",
+                    issueKey: routedIssue.identifier,
+                    projectId: project.id,
+                    status: "ignored",
+                    summary: "Ignored webhook from an untrusted actor",
+                });
+                this.db.markWebhookProcessed(webhookEventId, "processed");
+                return;
+            }
+            this.db.assignWebhookProject(webhookEventId, project.id);
+            const hydrated = await this.hydrateIssueContext(project.id, normalized);
+            const issue = hydrated.issue ?? routedIssue;
+            // Record desired stage and upsert issue
+            const result = this.recordDesiredStage(project, hydrated);
+            const trackedIssue = result.issue;
+            // Handle agent session events
+            await this.handleAgentSession(hydrated, project, trackedIssue, result.desiredStage, result.delegated);
+            // Handle comments during active run
+            await this.handleComment(hydrated, project, trackedIssue);
+            this.db.markWebhookProcessed(webhookEventId, "processed");
+            if (result.desiredStage) {
+                this.feed?.publish({
+                    level: "info",
+                    kind: "stage",
+                    issueKey: issue.identifier,
+                    projectId: project.id,
+                    stage: result.desiredStage,
+                    status: "queued",
+                    summary: `Queued ${result.desiredStage} workflow`,
+                    detail: `Triggered by ${hydrated.triggerEvent}.`,
+                });
+                this.enqueueIssue(project.id, issue.id);
+            }
+        }
+        catch (error) {
+            this.db.markWebhookProcessed(webhookEventId, "failed");
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.feed?.publish({
+                level: "error",
+                kind: "webhook",
+                projectId: undefined,
+                status: "failed",
+                summary: "Failed to process webhook",
+                detail: sanitizeDiagnosticText(err.message),
+            });
+            this.logger.error({ webhookEventId, webhookId: event.webhookId, error: sanitizeDiagnosticText(err.message) }, "Failed to process Linear webhook event");
+            throw err;
+        }
+    }
+    recordDesiredStage(project, normalized) {
+        const normalizedIssue = normalized.issue;
+        if (!normalizedIssue) {
+            return { issue: undefined, desiredStage: undefined, delegated: false };
+        }
+        const existingIssue = this.db.getIssue(project.id, normalizedIssue.id);
+        const activeRun = existingIssue?.activeRunId ? this.db.getRun(existingIssue.activeRunId) : undefined;
+        const delegated = this.isDelegatedToPatchRelay(project, normalized);
+        const triggerAllowed = triggerEventAllowed(project, normalized.triggerEvent);
+        // In the factory model, delegation → queue an implementation run.
+        // agentSessionCreated is itself a delegation signal (session exists because issue was delegated).
+        let pendingRunType;
+        const isDelegationSignal = delegated || normalized.triggerEvent === "agentSessionCreated";
+        if (isDelegationSignal && triggerAllowed && !activeRun && !existingIssue?.pendingRunType) {
+            pendingRunType = "implementation";
+        }
+        // Resolve agent session
+        const agentSessionId = normalized.agentSession?.id ??
+            (!activeRun && (pendingRunType || (normalized.triggerEvent === "delegateChanged" && !delegated)) ? null : undefined);
+        // Upsert the issue
+        const issue = this.db.upsertIssue({
+            projectId: project.id,
+            linearIssueId: normalizedIssue.id,
+            ...(normalizedIssue.identifier ? { issueKey: normalizedIssue.identifier } : {}),
+            ...(normalizedIssue.title ? { title: normalizedIssue.title } : {}),
+            ...(normalizedIssue.url ? { url: normalizedIssue.url } : {}),
+            ...(normalizedIssue.stateName ? { currentLinearState: normalizedIssue.stateName } : {}),
+            ...(pendingRunType ? { pendingRunType, factoryState: "delegated" } : {}),
+            ...(agentSessionId !== undefined ? { agentSessionId } : {}),
+        });
+        return {
+            issue: this.db.issueToTrackedIssue(issue),
+            desiredStage: pendingRunType,
+            delegated,
+        };
+    }
+    isDelegatedToPatchRelay(project, normalized) {
+        if (!normalized.issue)
+            return false;
+        const installation = this.db.linearInstallations.getLinearInstallationForProject(project.id);
+        if (!installation?.actorId)
+            return false;
+        return normalized.issue.delegateId === installation.actorId;
+    }
+    // ─── Agent session handling (inlined) ─────────────────────────────
+    async handleAgentSession(normalized, project, trackedIssue, desiredStage, delegated) {
+        if (!normalized.agentSession?.id || !normalized.issue)
+            return;
+        const linear = await this.linearProvider.forProject(project.id);
+        if (!linear)
+            return;
+        const existingIssue = this.db.getIssue(project.id, normalized.issue.id);
+        const activeRun = existingIssue?.activeRunId ? this.db.getRun(existingIssue.activeRunId) : undefined;
+        if (normalized.triggerEvent === "agentSessionCreated") {
+            if (!delegated) {
+                const body = "PatchRelay received your mention. Delegate the issue to PatchRelay to start work.";
+                await this.publishAgentActivity(linear, normalized.agentSession.id, { type: "elicitation", body });
+                return;
+            }
+            if (desiredStage) {
+                await this.updateAgentSessionPlan(linear, project, normalized.agentSession.id, trackedIssue, buildPreparingSessionPlan(desiredStage));
+                await this.publishAgentActivity(linear, normalized.agentSession.id, {
+                    type: "response",
+                    body: `PatchRelay started working on the ${desiredStage} workflow.`,
+                });
+                return;
+            }
+            if (activeRun) {
+                await this.updateAgentSessionPlan(linear, project, normalized.agentSession.id, trackedIssue, buildRunningSessionPlan(activeRun.runType));
+                await this.publishAgentActivity(linear, normalized.agentSession.id, {
+                    type: "response",
+                    body: `PatchRelay is already running the ${activeRun.runType} workflow for this issue.`,
+                });
+                return;
+            }
+            await this.publishAgentActivity(linear, normalized.agentSession.id, {
+                type: "elicitation",
+                body: "PatchRelay is delegated, but no work is queued. Delegate the issue or move it to Start to trigger implementation.",
+            });
+            return;
+        }
+        if (normalized.triggerEvent !== "agentPrompted")
+            return;
+        if (!triggerEventAllowed(project, normalized.triggerEvent))
+            return;
+        const promptBody = normalized.agentSession.promptBody?.trim();
+        if (activeRun && promptBody && activeRun.threadId && activeRun.turnId) {
+            // Deliver prompt directly to active Codex turn
+            const input = `New Linear agent prompt received while you are working.\n\n${promptBody}`;
+            try {
+                await this.codex.steerTurn({ threadId: activeRun.threadId, turnId: activeRun.turnId, input });
+                this.feed?.publish({
+                    level: "info",
+                    kind: "agent",
+                    projectId: project.id,
+                    issueKey: trackedIssue?.issueKey,
+                    stage: activeRun.runType,
+                    status: "delivered",
+                    summary: `Delivered follow-up prompt to active ${activeRun.runType} workflow`,
+                });
+            }
+            catch {
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "agent",
+                    projectId: project.id,
+                    issueKey: trackedIssue?.issueKey,
+                    stage: activeRun.runType,
+                    status: "delivery_failed",
+                    summary: `Could not deliver follow-up prompt to active ${activeRun.runType} workflow`,
+                });
+            }
+            await this.publishAgentActivity(linear, normalized.agentSession.id, {
+                type: "thought",
+                body: `PatchRelay routed your follow-up instructions into the active ${activeRun.runType} workflow.`,
+            });
+            return;
+        }
+        if (desiredStage) {
+            await this.updateAgentSessionPlan(linear, project, normalized.agentSession.id, trackedIssue, buildPreparingSessionPlan(desiredStage));
+            await this.publishAgentActivity(linear, normalized.agentSession.id, {
+                type: "response",
+                body: `PatchRelay is preparing the ${desiredStage} workflow from your latest prompt.`,
+            });
+        }
+    }
+    // ─── Comment handling (inlined) ───────────────────────────────────
+    async handleComment(normalized, project, trackedIssue) {
+        if ((normalized.triggerEvent !== "commentCreated" && normalized.triggerEvent !== "commentUpdated") ||
+            !normalized.comment?.body ||
+            !normalized.issue) {
+            return;
+        }
+        if (!triggerEventAllowed(project, normalized.triggerEvent))
+            return;
+        const issue = this.db.getIssue(project.id, normalized.issue.id);
+        if (!issue?.activeRunId)
+            return;
+        const run = this.db.getRun(issue.activeRunId);
+        if (!run?.threadId || !run.turnId)
+            return;
+        const body = [
+            "New Linear comment received while you are working.",
+            normalized.comment.userName ? `Author: ${normalized.comment.userName}` : undefined,
+            "",
+            normalized.comment.body.trim(),
+        ].filter(Boolean).join("\n");
+        try {
+            await this.codex.steerTurn({ threadId: run.threadId, turnId: run.turnId, input: body });
+            this.feed?.publish({
+                level: "info",
+                kind: "comment",
+                projectId: project.id,
+                issueKey: trackedIssue?.issueKey,
+                stage: run.runType,
+                status: "delivered",
+                summary: `Delivered follow-up comment to active ${run.runType} workflow`,
+            });
+        }
+        catch {
+            this.feed?.publish({
+                level: "warn",
+                kind: "comment",
+                projectId: project.id,
+                issueKey: trackedIssue?.issueKey,
+                stage: run.runType,
+                status: "delivery_failed",
+                summary: `Could not deliver follow-up comment to active ${run.runType} workflow`,
+            });
+        }
+    }
+    // ─── Helpers ──────────────────────────────────────────────────────
+    async publishAgentActivity(linear, agentSessionId, content) {
+        try {
+            await linear.createAgentActivity({
+                agentSessionId,
+                content,
+                ephemeral: content.type === "thought",
+            });
+        }
+        catch (error) {
+            this.logger.warn({ agentSessionId, error: error instanceof Error ? error.message : String(error) }, "Failed to publish Linear agent activity");
+        }
+    }
+    async updateAgentSessionPlan(linear, project, agentSessionId, issue, plan) {
+        if (!linear.updateAgentSession)
+            return;
+        try {
+            const externalUrls = buildAgentSessionExternalUrls(this.config, issue?.issueKey);
+            await linear.updateAgentSession({
+                agentSessionId,
+                ...(externalUrls ? { externalUrls } : {}),
+                plan,
+            });
+        }
+        catch (error) {
+            this.logger.warn({ agentSessionId, error: error instanceof Error ? error.message : String(error) }, "Failed to update Linear agent session");
+        }
+    }
+    async hydrateIssueContext(projectId, normalized) {
+        if (!normalized.issue)
+            return normalized;
+        if (normalized.triggerEvent !== "agentSessionCreated" && normalized.triggerEvent !== "agentPrompted")
+            return normalized;
+        if (hasCompleteIssueContext(normalized.issue))
+            return normalized;
+        const linear = await this.linearProvider.forProject(projectId);
+        if (!linear)
+            return normalized;
+        try {
+            const liveIssue = await linear.getIssue(normalized.issue.id);
+            return { ...normalized, issue: mergeIssueMetadata(normalized.issue, liveIssue) };
+        }
+        catch {
+            return normalized;
+        }
+    }
+    async tryHydrateProjectRoute(normalized) {
+        if (!normalized.issue)
+            return undefined;
+        if (normalized.triggerEvent !== "agentSessionCreated" && normalized.triggerEvent !== "agentPrompted")
+            return undefined;
+        for (const candidate of this.config.projects) {
+            const linear = await this.linearProvider.forProject(candidate.id);
+            if (!linear)
+                continue;
+            try {
+                const liveIssue = await linear.getIssue(normalized.issue.id);
+                const hydrated = { ...normalized, issue: mergeIssueMetadata(normalized.issue, liveIssue) };
+                const resolved = resolveProject(this.config, hydrated.issue);
+                if (resolved)
+                    return { project: resolved, normalized: hydrated };
+            }
+            catch { /* continue to next candidate */ }
+        }
+        return undefined;
+    }
+}
+function hasCompleteIssueContext(issue) {
+    return Boolean(issue.stateName && issue.delegateId && issue.teamId && issue.teamKey);
+}
+function mergeIssueMetadata(issue, liveIssue) {
+    return {
+        ...issue,
+        ...(issue.identifier ? {} : liveIssue.identifier ? { identifier: liveIssue.identifier } : {}),
+        ...(issue.title ? {} : liveIssue.title ? { title: liveIssue.title } : {}),
+        ...(issue.url ? {} : liveIssue.url ? { url: liveIssue.url } : {}),
+        ...(issue.teamId ? {} : liveIssue.teamId ? { teamId: liveIssue.teamId } : {}),
+        ...(issue.teamKey ? {} : liveIssue.teamKey ? { teamKey: liveIssue.teamKey } : {}),
+        ...(issue.stateId ? {} : liveIssue.stateId ? { stateId: liveIssue.stateId } : {}),
+        ...(issue.stateName ? {} : liveIssue.stateName ? { stateName: liveIssue.stateName } : {}),
+        ...(issue.delegateId ? {} : liveIssue.delegateId ? { delegateId: liveIssue.delegateId } : {}),
+        ...(issue.delegateName ? {} : liveIssue.delegateName ? { delegateName: liveIssue.delegateName } : {}),
+        labelNames: issue.labelNames.length > 0 ? issue.labelNames : (liveIssue.labels ?? []).map((l) => l.name),
+    };
+}

package/dist/webhook-installation-handler.js

@@ -8,9 +8,8 @@ export class InstallationWebhookHandler {
         this.logger = logger;
     }
     handle(normalized) {
-        if (!normalized.installation) {
+        if (!normalized.installation)
             return;
-        }
         if (normalized.triggerEvent === "installationPermissionsChanged") {
             const matchingInstallations = normalized.installation.appUserId
                 ? this.stores.linearInstallations
@@ -24,11 +23,7 @@ export class InstallationWebhookHandler {
                 const project = this.config.projects.find((entry) => entry.id === link.projectId);
                 const removedMatches = normalized.installation?.removedTeamIds.some((teamId) => project?.linearTeamIds.includes(teamId)) ?? false;
                 const addedMatches = normalized.installation?.addedTeamIds.some((teamId) => project?.linearTeamIds.includes(teamId)) ?? false;
-                return {
-                    projectId: link.projectId,
-                    removedMatches,
-                    addedMatches,
-                };
+                return { projectId: link.projectId, removedMatches, addedMatches };
             }));
             this.logger.warn({
                 appUserId: normalized.installation.appUserId,
@@ -43,7 +38,7 @@ export class InstallationWebhookHandler {
             this.logger.warn({
                 organizationId: normalized.installation.organizationId,
                 oauthClientId: normalized.installation.oauthClientId,
-            }, "Linear OAuth app installation was revoked; reconnect affected projects with `patchrelay project apply <id> <repo-path>` or `patchrelay connect --project <id>`");
+            }, "Linear OAuth app installation was revoked; reconnect affected projects");
             return;
         }
         if (normalized.triggerEvent === "appUserNotification") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.8.8",
+  "version": "0.9.0",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -33,6 +33,7 @@
     "start": "node dist/index.js serve",
     "doctor": "node dist/index.js doctor",
     "restart": "node dist/index.js restart-service",
+    "deploy": "npm run build && npm install -g . && node dist/index.js restart-service",
     "lint": "eslint .",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "check": "npm run typecheck",