opencode-magi 0.4.0 → 0.6.0

package/dist/orchestrator/run-manager.js

@@ -151,6 +151,12 @@ function ciReportText(input) {
     const scopeInside = input.report.scopeInside.length;
     return `CI report for ${input.pr}: ${failed} failed, ${scopeInside} scope-in, ${rerun} rerun, ${recovered} recovered, ${unresolved} unresolved.`;
 }
+function ciClassifierCompletedText(input) {
+    const summary = input.checks
+        .map((check) => `${check.name}: ${check.classification} - ${check.reason}`)
+        .join("; ");
+    return `**CI classifier ${input.reviewer}** completed for ${input.pr}: ${summary}`;
+}
 function closeReconsiderationText(input) {
     if (input.to === "MERGE") {
         return `**Reviewer ${input.reviewer}** changed their close request to approval for ${input.pr}.`;
@@ -403,6 +409,8 @@ function extractQuestionRequest(properties) {
 export class MagiRunManager {
     input;
     active = new Map();
+    activePrRuns = 0;
+    activeTriageRuns = 0;
     countedToolParts = new Map();
     controllers = new Map();
     eventLastUpdates = new Map();
@@ -410,6 +418,8 @@ export class MagiRunManager {
     runPaths = new Map();
     outputDirs = new Set();
     sessionToRun = new Map();
+    prQueue = [];
+    triageQueue = [];
     constructor(input) {
         this.input = input;
     }
@@ -453,13 +463,19 @@ export class MagiRunManager {
         await this.notify(state, `Started Magi review for ${prMarkdownLink(state)}.`);
         const controller = new AbortController();
         this.controllers.set(runId, controller);
-        void this.executeReview({
+        const execute = () => this.executeReview({
             ...input,
             runId,
             signal: controller.signal,
-        }).catch(async (error) => {
-            await this.failRun(runId, error);
         });
+        if (input.sync)
+            return this.executeSync(state, controller, execute, input.timeoutMs);
+        this.prQueue.push({
+            execute,
+            repository: input.repository,
+            runId,
+        });
+        this.drainPrQueue();
         return state;
     }
     async startMerge(input) {
@@ -511,13 +527,19 @@ export class MagiRunManager {
         await this.notify(state, `Started Magi merge for ${prMarkdownLink(state)}.`);
         const controller = new AbortController();
         this.controllers.set(runId, controller);
-        void this.executeMerge({
+        const execute = () => this.executeMerge({
             ...input,
             runId,
             signal: controller.signal,
-        }).catch(async (error) => {
-            await this.failRun(runId, error);
         });
+        if (input.sync)
+            return this.executeSync(state, controller, execute, input.timeoutMs);
+        this.prQueue.push({
+            execute,
+            repository: input.repository,
+            runId,
+        });
+        this.drainPrQueue();
         return state;
     }
     async startTriage(input) {
@@ -568,17 +590,70 @@ export class MagiRunManager {
         await this.notify(state, `Started Magi triage for ${issueMarkdownLink(state)}.`);
         const controller = new AbortController();
         this.controllers.set(runId, controller);
-        void this.executeTriage({
+        const execute = () => this.executeTriage({
             ...input,
             runId,
             signal: controller.signal,
-        }).catch(async (error) => {
-            await this.failRun(runId, error);
         });
+        if (input.sync)
+            return this.executeSync(state, controller, execute, input.timeoutMs);
+        this.triageQueue.push({
+            execute,
+            repository: input.repository,
+            runId,
+        });
+        this.drainTriageQueue();
         return state;
     }
+    drainPrQueue() {
+        while (this.prQueue.length) {
+            const next = this.prQueue[0];
+            if (!next)
+                return;
+            if (this.activePrRuns >= next.repository.concurrency.runs)
+                return;
+            this.prQueue.shift();
+            const state = this.active.get(next.runId);
+            if (!state || state.status === "cancelled")
+                continue;
+            this.activePrRuns += 1;
+            void next
+                .execute()
+                .catch(async (error) => {
+                await this.failRun(next.runId, error);
+            })
+                .finally(() => {
+                this.activePrRuns -= 1;
+                this.drainPrQueue();
+            });
+        }
+    }
+    drainTriageQueue() {
+        while (this.triageQueue.length) {
+            const next = this.triageQueue[0];
+            if (!next)
+                return;
+            const limit = next.repository.triage?.concurrency.runs ?? 1;
+            if (this.activeTriageRuns >= limit)
+                return;
+            this.triageQueue.shift();
+            const state = this.active.get(next.runId);
+            if (!state || state.status === "cancelled")
+                continue;
+            this.activeTriageRuns += 1;
+            void next
+                .execute()
+                .catch(async (error) => {
+                await this.failRun(next.runId, error);
+            })
+                .finally(() => {
+                this.activeTriageRuns -= 1;
+                this.drainTriageQueue();
+            });
+        }
+    }
     async status(input = {}) {
-        const timeoutMs = Math.min(input.timeoutMs ?? 60_000, 600_000);
+        const timeoutMs = input.timeoutMs;
         const startedAt = Date.now();
         while (input.block) {
             const states = await this.filteredStates(input);
@@ -586,7 +661,7 @@ export class MagiRunManager {
                 hasAllRequestedPrStates(states, input.pr) &&
                 states.every((state) => !isActiveStatus(state.status)))
                 return states;
-            if (Date.now() - startedAt >= timeoutMs)
+            if (timeoutMs != null && Date.now() - startedAt >= timeoutMs)
                 return states;
             await new Promise((resolve) => setTimeout(resolve, 1_000));
         }
@@ -638,53 +713,7 @@ export class MagiRunManager {
         state.status = "cancelled";
         state.phase = "cancelled";
         state.completedAt = now();
-        if (state.editor?.status === "pending" ||
-            state.editor?.status === "running" ||
-            state.editor?.status === "repairing") {
-            state.editor.status = "cancelled";
-        }
-        if (state.editor?.sessionId) {
-            await this.input.client.session
-                .abort?.({ path: { id: state.editor.sessionId } })
-                .catch(() => undefined);
-        }
-        if (state.triageCreator?.status === "pending" ||
-            state.triageCreator?.status === "running" ||
-            state.triageCreator?.status === "repairing" ||
-            state.triageCreator?.status === "blocked") {
-            state.triageCreator.status = "cancelled";
-        }
-        if (state.triageCreator?.sessionId) {
-            await this.input.client.session
-                .abort?.({ path: { id: state.triageCreator.sessionId } })
-                .catch(() => undefined);
-        }
-        for (const reviewer of Object.values(state.reviewers)) {
-            if (reviewer.status === "pending" ||
-                reviewer.status === "running" ||
-                reviewer.status === "repairing" ||
-                reviewer.status === "blocked") {
-                reviewer.status = "cancelled";
-            }
-            if (reviewer.sessionId) {
-                await this.input.client.session
-                    .abort?.({ path: { id: reviewer.sessionId } })
-                    .catch(() => undefined);
-            }
-        }
-        for (const classifier of Object.values(state.ciClassifiers ?? {})) {
-            if (classifier.status === "pending" ||
-                classifier.status === "running" ||
-                classifier.status === "repairing" ||
-                classifier.status === "blocked") {
-                classifier.status = "cancelled";
-            }
-            if (classifier.sessionId) {
-                await this.input.client.session
-                    .abort?.({ path: { id: classifier.sessionId } })
-                    .catch(() => undefined);
-            }
-        }
+        await this.finishActiveAgents(state, "cancelled");
         if (state.worktreePath) {
             await removeWorktree(this.input.exec, state.worktreePath).catch(() => undefined);
         }
@@ -1185,6 +1214,26 @@ export class MagiRunManager {
             ...Object.entries(state.reviewers),
         ];
     }
+    isActiveAgent(agent) {
+        return (agent.status === "pending" ||
+            agent.status === "running" ||
+            agent.status === "repairing" ||
+            agent.status === "blocked");
+    }
+    async finishActiveAgents(state, status, error) {
+        for (const [, agent] of this.agentEntries(state)) {
+            if (this.isActiveAgent(agent)) {
+                agent.status = status;
+                if (error != null)
+                    agent.error = error;
+            }
+            if (agent.sessionId) {
+                await this.input.client.session
+                    .abort?.({ path: { id: agent.sessionId } })
+                    .catch(() => undefined);
+            }
+        }
+    }
     selectPendingAgent(state, kind, key, requestId) {
         const entries = key
             ? this.agentState(state, key)
@@ -1210,6 +1259,41 @@ export class MagiRunManager {
     hasBlockedAgents(state) {
         return this.agentEntries(state).some(([, agent]) => agent.status === "blocked");
     }
+    async executeSync(state, controller, execute, timeoutMs) {
+        let timeout;
+        const timeoutPromise = timeoutMs == null
+            ? undefined
+            : new Promise((resolve) => {
+                timeout = setTimeout(() => resolve("timeout"), timeoutMs);
+            });
+        try {
+            const result = await (timeoutPromise
+                ? Promise.race([
+                    execute().then(() => "completed"),
+                    timeoutPromise,
+                ])
+                : execute().then(() => "completed"));
+            if (result === "timeout") {
+                const timeoutSeconds = (timeoutMs ?? 0) / 1_000;
+                controller.abort();
+                await this.failRun(state.runId, new Error(`Magi sync run timed out after ${timeoutSeconds} seconds.`));
+            }
+        }
+        catch (error) {
+            controller.abort();
+            await this.failRun(state.runId, error);
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+        }
+        return (await this.readStateByRunId(state.runId)) ?? state;
+    }
+    assertSuccessfulSyncFollowUp(state) {
+        if (state.status === "completed")
+            return;
+        throw new Error(`Synchronous follow-up ${state.command} run ${state.runId} finished with status ${state.status}.`);
+    }
     async executeReview(input) {
         const result = await runReview({
             approvalPolicy: input.repository.merge.approvalPolicy,
@@ -1219,6 +1303,7 @@ export class MagiRunManager {
             dryRun: input.dryRun,
             exec: withGitHubApiRetry(this.input.exec, input.config.github?.apiRetryAttempts ?? 3),
             onProgress: (progress) => this.applyReviewProgress(input.runId, progress),
+            parentSessionId: input.parentSessionId,
             pr: input.pr,
             repository: input.repository,
             runId: input.runId,
@@ -1274,6 +1359,7 @@ export class MagiRunManager {
             dryRun: input.dryRun,
             exec: withGitHubApiRetry(this.input.exec, input.config.github?.apiRetryAttempts ?? 3),
             onProgress: (progress) => this.applyMergeProgress(input.runId, progress),
+            parentSessionId: input.parentSessionId,
             pr: input.pr,
             repository: input.repository,
             runId: input.runId,
@@ -1315,6 +1401,7 @@ export class MagiRunManager {
             exec: withGitHubApiRetry(this.input.exec, input.config.github?.apiRetryAttempts ?? 3),
             issue: input.issue,
             onProgress: (progress) => this.applyTriageProgress(input.runId, progress),
+            parentSessionId: input.parentSessionId,
             repository: input.repository,
             runId: input.runId,
             signal: input.signal,
@@ -1347,24 +1434,32 @@ export class MagiRunManager {
             : undefined;
         const triageAutomation = input.repository.triage?.automation;
         if (followUpPr != null && triageAutomation?.merge) {
-            await this.startMerge({
+            const followUp = await this.startMerge({
                 config: input.config,
                 dryRun: input.dryRun,
                 parentSessionId: input.parentSessionId,
                 pr: followUpPr,
                 repository: input.repository,
                 signal: input.signal,
+                sync: input.sync,
+                timeoutMs: input.timeoutMs,
             });
+            if (input.sync)
+                this.assertSuccessfulSyncFollowUp(followUp);
         }
         else if (followUpPr != null && triageAutomation?.review) {
-            await this.startReview({
+            const followUp = await this.startReview({
                 config: input.config,
                 dryRun: input.dryRun,
                 parentSessionId: input.parentSessionId,
                 pr: followUpPr,
                 repository: input.repository,
                 signal: input.signal,
+                sync: input.sync,
+                timeoutMs: input.timeoutMs,
             });
+            if (input.sync)
+                this.assertSuccessfulSyncFollowUp(followUp);
         }
         this.active.delete(input.runId);
         this.controllers.delete(input.runId);
@@ -1405,57 +1500,69 @@ export class MagiRunManager {
             state.worktreePath = progress.worktreePath;
             state.worktreeBranch = progress.branch;
         }
+        if (progress.type === "triage_session") {
+            if (progress.options)
+                this.input.setSessionOptions?.(progress.sessionId, progress.options);
+            state.sessionIds = {
+                ...state.sessionIds,
+                [progress.key]: progress.sessionId,
+            };
+            this.sessionToRun.set(progress.sessionId, {
+                agent: progress.agent,
+                runId,
+            });
+        }
         if (progress.type === "triage_agent_started") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer)
-                reviewer.status = "running";
+            const voter = state.reviewers[progress.voter];
+            if (voter)
+                voter.status = "running";
         }
         if (progress.type === "triage_agent_session") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer) {
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
                 if (progress.options)
                     this.input.setSessionOptions?.(progress.sessionId, progress.options);
-                reviewer.sessionId = progress.sessionId;
-                reviewer.status = "running";
-                reviewer.lastUpdate = now();
+                voter.sessionId = progress.sessionId;
+                voter.status = "running";
+                voter.lastUpdate = now();
                 this.sessionToRun.set(progress.sessionId, {
-                    agent: progress.reviewer,
+                    agent: progress.voter,
                     runId,
                 });
             }
         }
         if (progress.type === "triage_agent_repair") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer) {
-                reviewer.status = "repairing";
-                reviewer.repairAttempts += 1;
-                reviewer.lastUpdate = now();
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
+                voter.status = "repairing";
+                voter.repairAttempts += 1;
+                voter.lastUpdate = now();
             }
         }
         if (progress.type === "triage_agent_response") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer) {
-                reviewer.sessionId = progress.sessionId;
-                reviewer.lastUpdate = now();
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
+                voter.sessionId = progress.sessionId;
+                voter.lastUpdate = now();
             }
         }
         if (progress.type === "triage_agent_completed") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer) {
-                reviewer.sessionId = progress.sessionId;
-                reviewer.status = "completed";
-                reviewer.verdict = progress.vote;
-                reviewer.rawPath = join(state.outputDir, `${progress.reviewer}.${progress.phase}.raw.txt`);
-                reviewer.parsedPath = join(state.outputDir, `${progress.reviewer}.${progress.phase}.json`);
-                reviewer.lastUpdate = now();
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
+                voter.sessionId = progress.sessionId;
+                voter.status = "completed";
+                voter.verdict = progress.vote;
+                voter.rawPath = join(state.outputDir, `${progress.voter}.${progress.phase}.raw.txt`);
+                voter.parsedPath = join(state.outputDir, `${progress.voter}.${progress.phase}.json`);
+                voter.lastUpdate = now();
             }
         }
         if (progress.type === "triage_agent_failed") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer) {
-                reviewer.status = "failed";
-                reviewer.error = redactSecrets(progress.error);
-                reviewer.lastUpdate = now();
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
+                voter.status = "failed";
+                voter.error = redactSecrets(progress.error);
+                voter.lastUpdate = now();
             }
         }
         if (progress.type === "triage_creator_started") {
@@ -1509,16 +1616,16 @@ export class MagiRunManager {
             }));
         }
         if (progress.type === "triage_agent_started") {
-            await this.notify(state, `**Triage agent ${progress.reviewer}** started ${progress.phase} for ${issue}.`);
+            await this.notify(state, `**Triage agent ${progress.voter}** started ${progress.phase} for ${issue}.`);
         }
         if (progress.type === "triage_agent_repair") {
-            await this.notify(state, `**Triage agent ${progress.reviewer}** started JSON regeneration for ${issue}.`);
+            await this.notify(state, `**Triage agent ${progress.voter}** started JSON regeneration for ${issue}.`);
         }
         if (progress.type === "triage_agent_completed") {
-            await this.notify(state, `**Triage agent ${progress.reviewer}** completed ${progress.phase} for ${issue}: ${progress.vote}.`);
+            await this.notify(state, `**Triage agent ${progress.voter}** completed ${progress.phase} for ${issue}: ${progress.vote}.`);
         }
         if (progress.type === "triage_agent_failed") {
-            await this.notify(state, `**Triage agent ${progress.reviewer}** failed ${progress.phase} for ${issue}: ${redactSecrets(progress.error)}`);
+            await this.notify(state, `**Triage agent ${progress.voter}** failed ${progress.phase} for ${issue}: ${redactSecrets(progress.error)}`);
         }
         if (progress.type === "comment_posting") {
             await this.notify(state, `Posting triage comment for ${issue}.`);
@@ -1603,9 +1710,8 @@ export class MagiRunManager {
         if (progress.type === "ci_classifier_completed") {
             const classifier = state.ciClassifiers?.[progress.reviewer];
             if (classifier) {
-                classifier.classification = progress.classification;
+                classifier.checks = progress.checks;
                 classifier.rawPath = progress.rawPath;
-                classifier.reason = progress.reason;
                 classifier.sessionId = progress.sessionId;
                 classifier.status = "completed";
                 classifier.lastUpdate = now();
@@ -1713,7 +1819,11 @@ export class MagiRunManager {
             await this.notify(state, `**CI classifier ${progress.reviewer}** started JSON regeneration for ${prMarkdownLink(state)}.`);
         }
         if (progress.type === "ci_classifier_completed") {
-            await this.notify(state, `**CI classifier ${progress.reviewer}** completed for ${prMarkdownLink(state)}: ${progress.classification} - ${progress.reason}`);
+            await this.notify(state, ciClassifierCompletedText({
+                checks: progress.checks,
+                pr: prMarkdownLink(state),
+                reviewer: progress.reviewer,
+            }));
         }
         if (progress.type === "ci_classifier_failed") {
             await this.notify(state, `**CI classifier ${progress.reviewer}** failed for ${prMarkdownLink(state)}: ${redactSecrets(progress.error)}`);
@@ -1882,46 +1992,7 @@ export class MagiRunManager {
         state.phase = "failed";
         state.completedAt = now();
         state.error = errorMessage(error);
-        if (state.editor?.status === "pending" ||
-            state.editor?.status === "running" ||
-            state.editor?.status === "repairing" ||
-            state.editor?.status === "blocked") {
-            state.editor.status = "failed";
-            state.editor.error = state.error;
-        }
-        if (state.editor?.sessionId) {
-            await this.input.client.session
-                .abort?.({ path: { id: state.editor.sessionId } })
-                .catch(() => undefined);
-        }
-        for (const reviewer of Object.values(state.reviewers)) {
-            if (reviewer.status === "pending" ||
-                reviewer.status === "running" ||
-                reviewer.status === "repairing" ||
-                reviewer.status === "blocked") {
-                reviewer.status = "failed";
-                reviewer.error = state.error;
-            }
-            if (reviewer.sessionId) {
-                await this.input.client.session
-                    .abort?.({ path: { id: reviewer.sessionId } })
-                    .catch(() => undefined);
-            }
-        }
-        for (const classifier of Object.values(state.ciClassifiers ?? {})) {
-            if (classifier.status === "pending" ||
-                classifier.status === "running" ||
-                classifier.status === "repairing" ||
-                classifier.status === "blocked") {
-                classifier.status = "failed";
-                classifier.error = state.error;
-            }
-            if (classifier.sessionId) {
-                await this.input.client.session
-                    .abort?.({ path: { id: classifier.sessionId } })
-                    .catch(() => undefined);
-            }
-        }
+        await this.finishActiveAgents(state, "failed", state.error);
         await this.persist(state);
         await this.notify(state, `Magi ${state.command} failed for ${runLabel(state)}: ${state.error}`, { reply: true });
         this.active.delete(runId);