patchrelay 0.36.7 → 0.36.9

package/dist/webhooks/issue-removal-handler.js

@@ -0,0 +1,68 @@
+import { TERMINAL_STATES } from "../factory-state.js";
+export class IssueRemovalHandler {
+    db;
+    feed;
+    constructor(db, feed) {
+        this.db = db;
+        this.feed = feed;
+    }
+    async handle(params) {
+        if (!params.trackedIssue)
+            return;
+        const removedIssue = this.db.issues.getIssue(params.projectId, params.issue.id);
+        const activeLease = this.db.issueSessions.getActiveIssueSessionLease(params.projectId, params.issue.id);
+        const commitRemoval = () => {
+            if (removedIssue?.activeRunId) {
+                const run = this.db.runs.getRunById(removedIssue.activeRunId);
+                if (run) {
+                    this.db.runs.finishRun(run.id, { status: "released", failureReason: "Issue removed from Linear" });
+                }
+                return this.db.issues.upsertIssue({
+                    projectId: params.projectId,
+                    linearIssueId: params.issue.id,
+                    activeRunId: null,
+                    pendingRunType: null,
+                    factoryState: "failed",
+                });
+            }
+            if (removedIssue && !TERMINAL_STATES.has(removedIssue.factoryState)) {
+                return this.db.issues.upsertIssue({
+                    projectId: params.projectId,
+                    linearIssueId: params.issue.id,
+                    pendingRunType: null,
+                    factoryState: "failed",
+                });
+            }
+            return removedIssue;
+        };
+        if (removedIssue?.activeRunId) {
+            const run = this.db.runs.getRunById(removedIssue.activeRunId);
+            if (run) {
+                await params.stopActiveRun(run, "STOP: The Linear issue was removed. Stop working immediately and exit.");
+            }
+        }
+        if (activeLease) {
+            this.db.issueSessions.withIssueSessionLease(params.projectId, params.issue.id, activeLease.leaseId, commitRemoval);
+        }
+        else {
+            commitRemoval();
+        }
+        this.db.issueSessions.appendIssueSessionEvent({
+            projectId: params.projectId,
+            linearIssueId: params.issue.id,
+            eventType: "issue_removed",
+            dedupeKey: `issue_removed:${params.issue.id}`,
+        });
+        this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(params.projectId, params.issue.id);
+        this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(params.projectId, params.issue.id);
+        this.feed?.publish({
+            level: "warn",
+            kind: "stage",
+            issueKey: params.issue.identifier,
+            projectId: params.projectId,
+            stage: "failed",
+            status: "issue_removed",
+            summary: "Issue removed from Linear",
+        });
+    }
+}

package/dist/worktree-manager.js

@@ -6,6 +6,75 @@ export class WorktreeManager {
     constructor(config) {
         this.config = config;
     }
+    async freshenWorktree(worktreePath, project, issue, logger) {
+        const gitBin = this.config.runner.gitBin;
+        const baseBranch = project.github?.baseBranch ?? "main";
+        const stashResult = await execCommand(gitBin, ["-C", worktreePath, "stash"], { timeoutMs: 30_000 });
+        const didStash = stashResult.exitCode === 0 && !stashResult.stdout?.includes("No local changes");
+        const fetchResult = await execCommand(gitBin, ["-C", worktreePath, "fetch", "origin", baseBranch], { timeoutMs: 60_000 });
+        if (fetchResult.exitCode !== 0) {
+            logger?.warn({ issueKey: issue.issueKey, stderr: fetchResult.stderr?.slice(0, 300) }, "Pre-run fetch failed, proceeding with current base");
+            if (didStash)
+                await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
+            return;
+        }
+        const mergeBaseResult = await execCommand(gitBin, ["-C", worktreePath, "merge-base", "--is-ancestor", `origin/${baseBranch}`, "HEAD"], { timeoutMs: 10_000 });
+        if (mergeBaseResult.exitCode === 0) {
+            logger?.debug({ issueKey: issue.issueKey }, "Pre-run freshen: branch already up to date");
+            if (didStash)
+                await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
+            return;
+        }
+        const rebaseResult = await execCommand(gitBin, ["-C", worktreePath, "rebase", `origin/${baseBranch}`], { timeoutMs: 120_000 });
+        if (rebaseResult.exitCode !== 0) {
+            await execCommand(gitBin, ["-C", worktreePath, "rebase", "--abort"], { timeoutMs: 10_000 });
+            if (didStash)
+                await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
+            logger?.warn({ issueKey: issue.issueKey, baseBranch }, "Pre-run freshen: rebase conflict, agent will resolve");
+            return;
+        }
+        logger?.info({ issueKey: issue.issueKey, baseBranch }, "Pre-run freshen: rebased locally onto latest base");
+        if (didStash)
+            await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
+    }
+    async resetWorktreeToTrackedBranch(worktreePath, branchName, issue, logger) {
+        const gitBin = this.config.runner.gitBin;
+        const branchFetch = await execCommand(gitBin, ["-C", worktreePath, "fetch", "origin", branchName], { timeoutMs: 60_000 });
+        const hasRemoteBranch = branchFetch.exitCode === 0;
+        await execCommand(gitBin, ["-C", worktreePath, "rebase", "--abort"], { timeoutMs: 10_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "merge", "--abort"], { timeoutMs: 10_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "cherry-pick", "--abort"], { timeoutMs: 10_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "am", "--abort"], { timeoutMs: 10_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "reset", "--hard", "HEAD"], { timeoutMs: 30_000 });
+        await execCommand(gitBin, ["-C", worktreePath, "clean", "-fd"], { timeoutMs: 30_000 });
+        const checkoutTarget = hasRemoteBranch ? `origin/${branchName}` : branchName;
+        const checkoutResult = await execCommand(gitBin, ["-C", worktreePath, "checkout", "-B", branchName, checkoutTarget], { timeoutMs: 30_000 });
+        if (checkoutResult.exitCode !== 0) {
+            throw new Error(`Failed to restore ${branchName} worktree state: ${checkoutResult.stderr?.slice(0, 300) ?? "git checkout failed"}`);
+        }
+        const resetTarget = hasRemoteBranch ? `origin/${branchName}` : "HEAD";
+        const resetResult = await execCommand(gitBin, ["-C", worktreePath, "reset", "--hard", resetTarget], { timeoutMs: 30_000 });
+        if (resetResult.exitCode !== 0) {
+            throw new Error(`Failed to reset ${branchName} worktree state: ${resetResult.stderr?.slice(0, 300) ?? "git reset failed"}`);
+        }
+        await execCommand(gitBin, ["-C", worktreePath, "clean", "-fd"], { timeoutMs: 30_000 });
+        logger?.debug({ issueKey: issue.issueKey, branchName, hasRemoteBranch }, "Reset issue worktree to tracked branch state");
+    }
+    async restoreIdleWorktree(issue, logger) {
+        if (!issue.worktreePath || !issue.branchName)
+            return;
+        try {
+            await this.resetWorktreeToTrackedBranch(issue.worktreePath, issue.branchName, issue, logger);
+        }
+        catch (error) {
+            logger?.warn({
+                issueKey: issue.issueKey,
+                branchName: issue.branchName,
+                worktreePath: issue.worktreePath,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to restore idle worktree after interrupted run");
+        }
+    }
     async ensureIssueWorktree(repoPath, worktreeRoot, worktreePath, branchName, options) {
         if (existsSync(worktreePath)) {
             await this.assertTrustedExistingWorktree(repoPath, worktreeRoot, worktreePath, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.36.7",
+  "version": "0.36.9",
   "license": "MIT",
   "type": "module",
   "repository": {