patchrelay 0.8.8 → 0.9.0

package/dist/service-stage-runner.js

@@ -1,336 +0,0 @@
-import { resolveAuthoritativeLinearStopState } from "./linear-workflow.js";
-import { buildStageLaunchPlan, isCodexThreadId } from "./stage-launch.js";
-import { syncFailedStageToLinear } from "./stage-failure.js";
-import { buildFailedStageReport } from "./stage-reporting.js";
-import { StageLifecyclePublisher } from "./stage-lifecycle-publisher.js";
-import { StageTurnInputDispatcher } from "./stage-turn-input-dispatcher.js";
-import { safeJsonParse } from "./utils.js";
-import { WorktreeManager } from "./worktree-manager.js";
-export class ServiceStageRunner {
-    config;
-    stores;
-    codex;
-    linearProvider;
-    logger;
-    feed;
-    worktreeManager;
-    inputDispatcher;
-    lifecyclePublisher;
-    runAtomically;
-    constructor(config, stores, codex, linearProvider, logger, runAtomically = (fn) => fn(), feed) {
-        this.config = config;
-        this.stores = stores;
-        this.codex = codex;
-        this.linearProvider = linearProvider;
-        this.logger = logger;
-        this.feed = feed;
-        this.runAtomically = runAtomically;
-        this.worktreeManager = new WorktreeManager(config);
-        this.inputDispatcher = new StageTurnInputDispatcher(stores, codex, logger);
-        this.lifecyclePublisher = new StageLifecyclePublisher(config, stores, linearProvider, logger, feed);
-    }
-    async run(item) {
-        const project = this.config.projects.find((candidate) => candidate.id === item.projectId);
-        if (!project) {
-            return;
-        }
-        const issueControl = this.stores.issueControl.getIssueControl(item.projectId, item.issueId);
-        if (!issueControl?.desiredStage || issueControl.activeRunLeaseId !== undefined) {
-            return;
-        }
-        const receipt = issueControl.desiredReceiptId !== undefined ? this.stores.eventReceipts.getEventReceipt(issueControl.desiredReceiptId) : undefined;
-        if (!receipt?.externalId) {
-            return;
-        }
-        const desiredStage = issueControl.desiredStage;
-        const desiredWebhookId = receipt.externalId;
-        const issue = await this.ensureLaunchIssueMirror(project, item.issueId, desiredStage, desiredWebhookId);
-        if (!issue) {
-            return;
-        }
-        if (issue.lifecycleStatus === "completed" || issue.lifecycleStatus === "paused") {
-            this.feed?.publish({
-                level: "info",
-                kind: "workflow",
-                issueKey: issue.issueKey,
-                projectId: item.projectId,
-                stage: desiredStage,
-                ...(issue.selectedWorkflowId ? { workflowId: issue.selectedWorkflowId } : {}),
-                status: issue.lifecycleStatus === "completed" ? "completed" : "transition_suppressed",
-                summary: issue.lifecycleStatus === "completed"
-                    ? `Skipped ${desiredStage} because the issue is already complete`
-                    : `Skipped ${desiredStage} because the issue is already paused`,
-                detail: issue.currentLinearState ? `Live Linear state is ${issue.currentLinearState}.` : undefined,
-            });
-            return;
-        }
-        const existingWorkspace = this.stores.workspaceOwnership.getWorkspaceOwnershipForIssue(item.projectId, item.issueId);
-        const stageHistory = this.stores.issueWorkflows.listStageRunsForIssue(item.projectId, item.issueId);
-        const previousStageRun = stageHistory.at(-1);
-        const defaultPlan = buildStageLaunchPlan(project, issue, desiredStage, {
-            ...(previousStageRun ? { previousStageRun } : {}),
-            ...(existingWorkspace
-                ? {
-                    workspace: {
-                        branchName: existingWorkspace.branchName,
-                        worktreePath: existingWorkspace.worktreePath,
-                    },
-                }
-                : {}),
-            stageHistory,
-        });
-        const plan = existingWorkspace
-            ? {
-                ...defaultPlan,
-                branchName: existingWorkspace.branchName,
-                worktreePath: existingWorkspace.worktreePath,
-            }
-            : defaultPlan;
-        this.feed?.publish({
-            level: "info",
-            kind: "stage",
-            issueKey: issue.issueKey,
-            projectId: item.projectId,
-            stage: desiredStage,
-            ...(issue.selectedWorkflowId ? { workflowId: issue.selectedWorkflowId } : {}),
-            status: "starting",
-            summary: `Starting ${desiredStage} workflow`,
-            detail: `Preparing ${plan.branchName}`,
-        });
-        const claim = this.stores.workflowCoordinator.claimStageRun({
-            projectId: item.projectId,
-            linearIssueId: item.issueId,
-            stage: desiredStage,
-            triggerWebhookId: desiredWebhookId,
-            branchName: plan.branchName,
-            worktreePath: plan.worktreePath,
-            workflowFile: plan.workflowFile,
-            promptText: plan.prompt,
-        });
-        if (!claim) {
-            return;
-        }
-        let threadLaunch;
-        let turn;
-        try {
-            await this.worktreeManager.ensureIssueWorktree(project.repoPath, project.worktreeRoot, plan.worktreePath, plan.branchName, {
-                allowExistingOutsideRoot: existingWorkspace !== undefined,
-            });
-            await this.lifecyclePublisher.markStageActive(project, claim.issue, claim.stageRun);
-            threadLaunch = await this.launchStageThread(item.projectId, item.issueId, claim.stageRun.id, plan.worktreePath);
-            const pendingLaunchInput = this.collectPendingLaunchInput(item.projectId, item.issueId);
-            const initialTurnInput = pendingLaunchInput.combinedInput
-                ? [plan.prompt, "", pendingLaunchInput.combinedInput].join("\n")
-                : plan.prompt;
-            turn = await this.codex.startTurn({
-                threadId: threadLaunch.threadId,
-                cwd: plan.worktreePath,
-                input: initialTurnInput,
-            });
-            this.completeDeliveredLaunchInput(pendingLaunchInput.obligationIds, claim.stageRun.id, threadLaunch.threadId, turn.turnId);
-        }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            await this.markLaunchFailed(project, claim.issue, claim.stageRun, err.message, threadLaunch?.threadId);
-            this.logger.error({
-                issueKey: issue.issueKey,
-                stage: claim.stageRun.stage,
-                worktreePath: plan.worktreePath,
-                branchName: plan.branchName,
-                error: err.message,
-                stack: err.stack,
-            }, "Failed to launch Codex stage run");
-            this.feed?.publish({
-                level: "error",
-                kind: "stage",
-                issueKey: issue.issueKey,
-                projectId: item.projectId,
-                stage: claim.stageRun.stage,
-                status: "failed",
-                summary: `Failed to launch ${claim.stageRun.stage} workflow`,
-                detail: err.message,
-            });
-            throw err;
-        }
-        this.stores.workflowCoordinator.updateStageRunThread({
-            stageRunId: claim.stageRun.id,
-            threadId: threadLaunch.threadId,
-            ...(threadLaunch.parentThreadId ? { parentThreadId: threadLaunch.parentThreadId } : {}),
-            turnId: turn.turnId,
-        });
-        this.inputDispatcher.routePendingInputs(claim.stageRun, threadLaunch.threadId, turn.turnId);
-        const deliveredToSession = await this.lifecyclePublisher.publishStageStarted(claim.issue, claim.stageRun.stage);
-        if (!deliveredToSession && !claim.issue.activeAgentSessionId) {
-            await this.lifecyclePublisher.refreshRunningStatusComment(item.projectId, item.issueId, claim.stageRun.id, issue.issueKey);
-        }
-        this.logger.info({
-            issueKey: issue.issueKey,
-            stage: claim.stageRun.stage,
-            worktreePath: plan.worktreePath,
-            branchName: plan.branchName,
-            threadId: threadLaunch.threadId,
-            turnId: turn.turnId,
-        }, "Started Codex stage run");
-        this.feed?.publish({
-            level: "info",
-            kind: "stage",
-            issueKey: issue.issueKey,
-            projectId: item.projectId,
-            stage: claim.stageRun.stage,
-            ...(claim.issue.selectedWorkflowId ? { workflowId: claim.issue.selectedWorkflowId } : {}),
-            status: "running",
-            summary: `Started ${claim.stageRun.stage} workflow`,
-            detail: `Turn ${turn.turnId} is running in ${plan.branchName}.`,
-        });
-    }
-    collectPendingLaunchInput(projectId, issueId) {
-        const obligationIds = [];
-        const bodies = [];
-        for (const obligation of this.stores.obligations.listPendingObligations({ kind: "deliver_turn_input" })) {
-            if (obligation.projectId !== projectId ||
-                obligation.linearIssueId !== issueId ||
-                !obligation.source.startsWith("linear-agent-launch:")) {
-                continue;
-            }
-            const payload = safeJsonParse(obligation.payloadJson);
-            const body = payload?.body?.trim();
-            if (!body) {
-                this.stores.obligations.markObligationStatus(obligation.id, "failed", "obligation payload had no deliverable body");
-                continue;
-            }
-            obligationIds.push(obligation.id);
-            bodies.push(body);
-        }
-        return {
-            ...(bodies.length > 0 ? { combinedInput: bodies.join("\n\n") } : {}),
-            obligationIds,
-        };
-    }
-    completeDeliveredLaunchInput(obligationIds, runLeaseId, threadId, turnId) {
-        for (const obligationId of obligationIds) {
-            this.stores.obligations.updateObligationRouting(obligationId, {
-                runLeaseId,
-                threadId,
-                turnId,
-            });
-            this.stores.obligations.markObligationStatus(obligationId, "completed");
-        }
-    }
-    async ensureLaunchIssueMirror(project, linearIssueId, _desiredStage, _desiredWebhookId) {
-        const existing = this.stores.issueWorkflows.getTrackedIssue(project.id, linearIssueId);
-        const liveIssue = await this.linearProvider
-            .forProject(project.id)
-            .then((linear) => linear?.getIssue(linearIssueId))
-            .catch(() => undefined);
-        const authoritativeStopState = liveIssue ? resolveAuthoritativeLinearStopState(liveIssue) : undefined;
-        if (authoritativeStopState) {
-            this.stores.workflowCoordinator.setIssueDesiredStage(project.id, linearIssueId, undefined, {
-                lifecycleStatus: authoritativeStopState.lifecycleStatus,
-            });
-            return this.stores.workflowCoordinator.upsertTrackedIssue({
-                projectId: project.id,
-                linearIssueId,
-                ...(liveIssue?.identifier ? { issueKey: liveIssue.identifier } : existing?.issueKey ? { issueKey: existing.issueKey } : {}),
-                ...(liveIssue?.title ? { title: liveIssue.title } : existing?.title ? { title: existing.title } : {}),
-                ...(liveIssue?.url ? { issueUrl: liveIssue.url } : existing?.issueUrl ? { issueUrl: existing.issueUrl } : {}),
-                currentLinearState: authoritativeStopState.stateName,
-                lifecycleStatus: authoritativeStopState.lifecycleStatus,
-            });
-        }
-        if (!liveIssue && existing?.issueKey && existing.title && existing.issueUrl && existing.currentLinearState) {
-            return existing;
-        }
-        return this.stores.workflowCoordinator.recordDesiredStage({
-            projectId: project.id,
-            linearIssueId,
-            ...(liveIssue?.identifier ? { issueKey: liveIssue.identifier } : existing?.issueKey ? { issueKey: existing.issueKey } : {}),
-            ...(liveIssue?.title ? { title: liveIssue.title } : existing?.title ? { title: existing.title } : {}),
-            ...(liveIssue?.url ? { issueUrl: liveIssue.url } : existing?.issueUrl ? { issueUrl: existing.issueUrl } : {}),
-            ...(liveIssue?.stateName
-                ? { currentLinearState: liveIssue.stateName }
-                : existing?.currentLinearState
-                    ? { currentLinearState: existing.currentLinearState }
-                    : {}),
-            lastWebhookAt: new Date().toISOString(),
-        });
-    }
-    async launchStageThread(projectId, issueId, stageRunId, worktreePath) {
-        const previousStageRun = this.stores.issueWorkflows
-            .listStageRunsForIssue(projectId, issueId)
-            .filter((stageRun) => stageRun.id !== stageRunId)
-            .at(-1);
-        const parentThreadId = previousStageRun?.status === "completed" && isCodexThreadId(previousStageRun.threadId)
-            ? previousStageRun.threadId
-            : undefined;
-        const thread = await this.codex.startThread({ cwd: worktreePath });
-        return {
-            threadId: thread.id,
-            ...(parentThreadId ? { parentThreadId } : {}),
-        };
-    }
-    async markLaunchFailed(project, issue, stageRun, message, threadId) {
-        const failureThreadId = threadId ?? `launch-failed-${stageRun.id}`;
-        this.runAtomically(() => {
-            this.stores.workflowCoordinator.finishStageRun({
-                stageRunId: stageRun.id,
-                status: "failed",
-                threadId: failureThreadId,
-                summaryJson: JSON.stringify({ message }),
-                reportJson: JSON.stringify(buildFailedStageReport(stageRun, "failed", { threadId: failureThreadId })),
-            });
-            this.finishRunLease(stageRun.projectId, stageRun.linearIssueId, "failed", {
-                threadId: failureThreadId,
-                failureReason: message,
-            });
-        });
-        await syncFailedStageToLinear({
-            stores: this.stores,
-            linearProvider: this.linearProvider,
-            project,
-            issue,
-            stageRun: {
-                ...stageRun,
-                threadId: failureThreadId,
-            },
-            message,
-            mode: "launch",
-        });
-    }
-    finishRunLease(projectId, linearIssueId, status, params) {
-        const issueControl = this.stores.issueControl.getIssueControl(projectId, linearIssueId);
-        if (!issueControl?.activeRunLeaseId) {
-            return;
-        }
-        this.stores.runLeases.finishRunLease({
-            runLeaseId: issueControl.activeRunLeaseId,
-            status,
-            ...(params.threadId ? { threadId: params.threadId } : {}),
-            ...(params.turnId ? { turnId: params.turnId } : {}),
-            ...(params.failureReason ? { failureReason: params.failureReason } : {}),
-        });
-        if (issueControl.activeWorkspaceOwnershipId !== undefined) {
-            const workspace = this.stores.workspaceOwnership.getWorkspaceOwnership(issueControl.activeWorkspaceOwnershipId);
-            if (workspace) {
-                this.stores.workspaceOwnership.upsertWorkspaceOwnership({
-                    projectId,
-                    linearIssueId,
-                    branchName: workspace.branchName,
-                    worktreePath: workspace.worktreePath,
-                    status: "paused",
-                    currentRunLeaseId: null,
-                });
-            }
-        }
-        this.stores.issueControl.upsertIssueControl({
-            projectId,
-            linearIssueId,
-            activeRunLeaseId: null,
-            lifecycleStatus: "failed",
-            ...(issueControl.activeWorkspaceOwnershipId !== undefined
-                ? { activeWorkspaceOwnershipId: issueControl.activeWorkspaceOwnershipId }
-                : {}),
-            ...(issueControl.serviceOwnedCommentId ? { serviceOwnedCommentId: issueControl.serviceOwnedCommentId } : {}),
-            ...(issueControl.activeAgentSessionId ? { activeAgentSessionId: issueControl.activeAgentSessionId } : {}),
-        });
-    }
-}