patchrelay 0.2.0 → 0.4.0

package/dist/cli/data.js

@@ -1,6 +1,8 @@
+import { existsSync } from "node:fs";
 import pino from "pino";
 import { CodexAppServerClient } from "../codex-app-server.js";
 import { PatchRelayDatabase } from "../db.js";
+import { WorktreeManager } from "../worktree-manager.js";
 import { resolveWorkflowStage } from "../workflow-policy.js";
 function safeJsonParse(value) {
     if (!value) {
@@ -167,16 +169,43 @@ export class CliDataAccess {
         if (!worktree) {
             return undefined;
         }
-        const ledger = this.getLedgerIssueContext(worktree.issue.projectId, worktree.issue.linearIssueId);
-        const resumeThreadId = (ledger.issueControl?.activeRunLeaseId ? ledger.runLease?.threadId : undefined) ??
-            worktree.workspace.lastThreadId ??
-            worktree.issue.latestThreadId ??
-            ledger.runLease?.threadId;
+        const resumeThreadId = this.getStoredOpenThreadId(worktree);
         return {
             ...worktree,
             ...(resumeThreadId ? { resumeThreadId } : {}),
         };
     }
+    async prepareOpen(issueKey) {
+        const worktree = this.worktree(issueKey);
+        if (!worktree) {
+            return undefined;
+        }
+        await this.ensureOpenWorktree(worktree);
+        const existingThreadId = await this.resolveStoredOpenThreadId(worktree);
+        if (existingThreadId) {
+            return {
+                ...worktree,
+                resumeThreadId: existingThreadId,
+            };
+        }
+        const codex = await this.getCodex();
+        const thread = await codex.startThread({
+            cwd: worktree.workspace.worktreePath,
+        });
+        this.db.issueSessions.upsertIssueSession({
+            projectId: worktree.issue.projectId,
+            linearIssueId: worktree.issue.linearIssueId,
+            workspaceOwnershipId: worktree.workspace.id,
+            threadId: thread.id,
+            source: "operator_open",
+            ...(worktree.issue.activeAgentSessionId ? { linkedAgentSessionId: worktree.issue.activeAgentSessionId } : {}),
+        });
+        this.db.issueSessions.touchIssueSession(thread.id);
+        return {
+            ...worktree,
+            resumeThreadId: thread.id,
+        };
+    }
     retry(issueKey, options) {
         const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
         if (!issue) {
@@ -200,14 +229,10 @@ export class CliDataAccess {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
         });
-        this.db.issueControl.upsertIssueControl({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            desiredStage: stage,
+        this.db.workflowCoordinator.setIssueDesiredStage(issue.projectId, issue.linearIssueId, stage, {
             desiredReceiptId: receipt.id,
             lifecycleStatus: "queued",
         });
-        this.db.issueWorkflows.setIssueDesiredStage(issue.projectId, issue.linearIssueId, stage, webhookId);
         const updated = this.db.issueWorkflows.getTrackedIssue(issue.projectId, issue.linearIssueId);
         return {
             issue: updated,
@@ -278,13 +303,19 @@ export class CliDataAccess {
                         : {}),
                 ...(row.latest_stage !== null
                     ? { latestStage: row.latest_stage }
-                    : ledger?.mirroredStageRun
-                        ? { latestStage: ledger.mirroredStageRun.stage }
+                    : ledger?.runLease
+                        ? { latestStage: ledger.runLease.stage }
                         : {}),
                 ...(row.latest_stage_status !== null
                     ? { latestStageStatus: String(row.latest_stage_status) }
-                    : ledger?.mirroredStageRun
-                        ? { latestStageStatus: ledger.mirroredStageRun.status }
+                    : ledger?.runLease
+                        ? {
+                            latestStageStatus: ledger.runLease.status === "failed"
+                                ? "failed"
+                                : ledger.runLease.status === "completed" || ledger.runLease.status === "released" || ledger.runLease.status === "paused"
+                                    ? "completed"
+                                    : "running",
+                        }
                         : {}),
                 updatedAt: String(row.updated_at),
             };
@@ -302,20 +333,16 @@ export class CliDataAccess {
     getLedgerIssueContext(projectId, linearIssueId) {
         const issueControl = this.db.issueControl.getIssueControl(projectId, linearIssueId);
         const runLease = issueControl?.activeRunLeaseId ? this.db.runLeases.getRunLease(issueControl.activeRunLeaseId) : undefined;
-        const workspaceOwnership = issueControl?.activeWorkspaceOwnershipId
-            ? this.db.workspaceOwnership.getWorkspaceOwnership(issueControl.activeWorkspaceOwnershipId)
-            : undefined;
-        const mirroredStageRun = issueControl?.activeRunLeaseId ? this.db.issueWorkflows.getStageRun(issueControl.activeRunLeaseId) : undefined;
         return {
             ...(issueControl ? { issueControl } : {}),
             ...(runLease ? { runLease } : {}),
-            ...(workspaceOwnership ? { workspaceOwnership } : {}),
-            ...(mirroredStageRun ? { mirroredStageRun } : {}),
         };
     }
     getActiveStageRunForIssue(issue, ledger) {
         const context = ledger ?? this.getLedgerIssueContext(issue.projectId, issue.linearIssueId);
-        const activeStageRun = context.mirroredStageRun ?? this.synthesizeStageRunFromLease(context);
+        const activeStageRun = context.issueControl?.activeRunLeaseId
+            ? this.db.issueWorkflows.getStageRun(context.issueControl.activeRunLeaseId)
+            : undefined;
         if (!activeStageRun) {
             return undefined;
         }
@@ -323,59 +350,89 @@ export class CliDataAccess {
             ? activeStageRun
             : undefined;
     }
-    synthesizeStageRunFromLease(ledger) {
-        if (!ledger.runLease) {
-            return undefined;
-        }
-        return {
-            id: -ledger.runLease.id,
-            pipelineRunId: 0,
-            projectId: ledger.runLease.projectId,
-            linearIssueId: ledger.runLease.linearIssueId,
-            workspaceId: 0,
-            stage: ledger.runLease.stage,
-            status: ledger.runLease.status === "failed"
-                ? "failed"
-                : ledger.runLease.status === "completed" || ledger.runLease.status === "released" || ledger.runLease.status === "paused"
-                    ? "completed"
-                    : "running",
-            triggerWebhookId: "ledger-active-run",
-            workflowFile: ledger.runLease.workflowFile,
-            promptText: ledger.runLease.promptText,
-            ...(ledger.runLease.threadId ? { threadId: ledger.runLease.threadId } : {}),
-            ...(ledger.runLease.parentThreadId ? { parentThreadId: ledger.runLease.parentThreadId } : {}),
-            ...(ledger.runLease.turnId ? { turnId: ledger.runLease.turnId } : {}),
-            startedAt: ledger.runLease.startedAt,
-            ...(ledger.runLease.endedAt ? { endedAt: ledger.runLease.endedAt } : {}),
-        };
-    }
     getWorkspaceForIssue(issue, ledger) {
         const context = ledger ?? this.getLedgerIssueContext(issue.projectId, issue.linearIssueId);
-        if (!context.issueControl?.activeRunLeaseId) {
-            const activeWorkspace = this.db.issueWorkflows.getActiveWorkspaceForIssue(issue.projectId, issue.linearIssueId);
+        if (context.issueControl?.activeWorkspaceOwnershipId !== undefined) {
+            const activeWorkspace = this.db.issueWorkflows.getWorkspace(context.issueControl.activeWorkspaceOwnershipId);
             if (activeWorkspace) {
                 return activeWorkspace;
             }
         }
-        const workspaceOwnership = context.workspaceOwnership;
-        if (!workspaceOwnership) {
-            return this.db.issueWorkflows.getActiveWorkspaceForIssue(issue.projectId, issue.linearIssueId);
+        return this.db.issueWorkflows.getActiveWorkspaceForIssue(issue.projectId, issue.linearIssueId);
+    }
+    getStoredOpenThreadId(worktree) {
+        return this.listOpenCandidateThreadIds(worktree).at(0);
+    }
+    async resolveStoredOpenThreadId(worktree) {
+        for (const threadId of this.listOpenCandidateThreadIds(worktree)) {
+            if (!(await this.canReadThread(threadId))) {
+                continue;
+            }
+            this.recordOpenThreadForIssue(worktree, threadId);
+            return threadId;
         }
-        return {
-            id: workspaceOwnership.id,
-            projectId: workspaceOwnership.projectId,
-            linearIssueId: workspaceOwnership.linearIssueId,
-            branchName: workspaceOwnership.branchName,
-            worktreePath: workspaceOwnership.worktreePath,
-            status: workspaceOwnership.status === "released"
-                ? "closed"
-                : workspaceOwnership.status === "paused"
-                    ? "paused"
-                    : "active",
-            ...(context.runLease?.threadId ? { lastThreadId: context.runLease.threadId } : {}),
-            createdAt: workspaceOwnership.createdAt,
-            updatedAt: workspaceOwnership.updatedAt,
-        };
+        return undefined;
+    }
+    listOpenCandidateThreadIds(worktree) {
+        const ledger = this.getLedgerIssueContext(worktree.issue.projectId, worktree.issue.linearIssueId);
+        const sessions = this.db.issueSessions.listIssueSessionsForIssue(worktree.issue.projectId, worktree.issue.linearIssueId);
+        const candidates = [
+            ledger.issueControl?.activeRunLeaseId ? ledger.runLease?.threadId : undefined,
+            ...sessions.map((session) => session.threadId),
+            worktree.workspace.lastThreadId,
+            worktree.issue.latestThreadId,
+            ledger.runLease?.threadId,
+        ];
+        const seen = new Set();
+        const ordered = [];
+        for (const candidate of candidates) {
+            if (!candidate || seen.has(candidate)) {
+                continue;
+            }
+            seen.add(candidate);
+            ordered.push(candidate);
+        }
+        return ordered;
+    }
+    recordOpenThreadForIssue(worktree, threadId) {
+        const existing = this.db.issueSessions.getIssueSessionByThreadId(threadId);
+        if (existing) {
+            this.db.issueSessions.touchIssueSession(threadId);
+            return;
+        }
+        const runLease = this.db.runLeases.getRunLeaseByThreadId(threadId);
+        this.db.issueSessions.upsertIssueSession({
+            projectId: worktree.issue.projectId,
+            linearIssueId: worktree.issue.linearIssueId,
+            workspaceOwnershipId: runLease?.workspaceOwnershipId ?? worktree.workspace.id,
+            threadId,
+            source: runLease ? "stage_run" : "operator_open",
+            ...(runLease?.id !== undefined ? { runLeaseId: runLease.id } : {}),
+            ...(runLease?.parentThreadId ? { parentThreadId: runLease.parentThreadId } : {}),
+            ...(worktree.issue.activeAgentSessionId ? { linkedAgentSessionId: worktree.issue.activeAgentSessionId } : {}),
+        });
+        this.db.issueSessions.touchIssueSession(threadId);
+    }
+    async canReadThread(threadId) {
+        try {
+            const codex = await this.getCodex();
+            await codex.readThread(threadId, false);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async ensureOpenWorktree(worktree) {
+        if (existsSync(worktree.workspace.worktreePath)) {
+            return;
+        }
+        const project = this.config.projects.find((entry) => entry.id === worktree.repoId);
+        if (!project) {
+            throw new Error(`Project not found for ${worktree.repoId}`);
+        }
+        const worktreeManager = new WorktreeManager(this.config);
+        await worktreeManager.ensureIssueWorktree(project.repoPath, project.worktreeRoot, worktree.workspace.worktreePath, worktree.workspace.branchName);
     }
     async connect(projectId) {
         return await this.requestJson("/api/oauth/linear/start", {