opencode-magi 0.0.0-dev-20260521143330 → 0.0.0-dev-20260521143913

package/dist/index.js

@@ -95,12 +95,17 @@ export function parseRunArguments(value, dryRun = false, command = "review") {
     const tokens = value.split(/[\s,]+/).filter(Boolean);
     const configOverrides = {};
     const prTokens = [];
+    let sync = false;
     for (let index = 0; index < tokens.length; index++) {
         const token = tokens[index];
         if (token === "--dry-run") {
             dryRun = true;
             continue;
         }
+        if (token === "--sync") {
+            sync = true;
+            continue;
+        }
         switch (token) {
             case "--language":
                 setConfigOverride(configOverrides, ["language"], nextFlagValue(tokens, ++index, token));
@@ -146,18 +151,23 @@ export function parseRunArguments(value, dryRun = false, command = "review") {
                 prTokens.push(token);
         }
     }
-    return { configOverrides, dryRun, prs: parsePrs(prTokens.join(" ")) };
+    return { configOverrides, dryRun, prs: parsePrs(prTokens.join(" ")), sync };
 }
 export function parseIssueRunArguments(value, dryRun = false) {
     const tokens = value.split(/[\s,]+/).filter(Boolean);
     const configOverrides = {};
     const issueTokens = [];
+    let sync = false;
     for (let index = 0; index < tokens.length; index++) {
         const token = tokens[index];
         if (token === "--dry-run") {
             dryRun = true;
             continue;
         }
+        if (token === "--sync") {
+            sync = true;
+            continue;
+        }
         switch (token) {
             case "--language":
                 setConfigOverride(configOverrides, ["language"], nextFlagValue(tokens, ++index, token));
@@ -195,7 +205,12 @@ export function parseIssueRunArguments(value, dryRun = false) {
                 issueTokens.push(token);
         }
     }
-    return { configOverrides, dryRun, issues: parseIssues(issueTokens.join(" ")) };
+    return {
+        configOverrides,
+        dryRun,
+        issues: parseIssues(issueTokens.join(" ")),
+        sync,
+    };
 }
 function nextFlagValue(tokens, index, flag) {
     const value = tokens[index];
@@ -203,6 +218,15 @@ function nextFlagValue(tokens, index, flag) {
         throw new Error(`${flag} requires a value.`);
     return value;
 }
+async function syncResult(runManager, states) {
+    const output = await runManager.formatStatesWithReports(states, {
+        verbose: true,
+    });
+    const failed = states.filter((state) => state.status !== "completed");
+    if (failed.length)
+        throw new Error(output);
+    return output;
+}
 function parseIntegerFlag(value, flag, minimum) {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isInteger(parsed) ||
@@ -432,6 +456,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                 args: {
                     prs: tool.schema.string(),
                     dryRun: tool.schema.boolean().optional(),
+                    sync: tool.schema.boolean().optional(),
                 },
                 async execute(args, context) {
                     const parsed = parseRunArguments(args.prs, args.dryRun ?? false, "merge");
@@ -448,6 +473,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                     if (!validation.ok)
                         return JSON.stringify(validation, null, 2);
                     const repository = resolveRepository(config);
+                    const sync = parsed.sync || args.sync === true;
                     const states = await mapPool(parsed.prs, repository.concurrency.runs, (pr) => runManager.startMerge({
                         config,
                         dryRun: parsed.dryRun,
@@ -455,7 +481,10 @@ export const MagiPlugin = async ({ client, directory }) => {
                         pr,
                         parentSessionId: context.sessionID,
                         signal: context.abort,
+                        sync,
                     }), { signal: context.abort });
+                    if (sync)
+                        return syncResult(runManager, states);
                     return states
                         .map((state) => `Started reviewing ${prMarkdownLink(repository, state.pr)}.`)
                         .join("\n");
@@ -469,6 +498,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                 args: {
                     prs: tool.schema.string(),
                     dryRun: tool.schema.boolean().optional(),
+                    sync: tool.schema.boolean().optional(),
                 },
                 async execute(args, context) {
                     const parsed = parseRunArguments(args.prs, args.dryRun ?? false);
@@ -484,6 +514,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                     if (!validation.ok)
                         return JSON.stringify(validation, null, 2);
                     const repository = resolveRepository(config);
+                    const sync = parsed.sync || args.sync === true;
                     const states = await mapPool(parsed.prs, repository.concurrency.runs, (pr) => runManager.startReview({
                         config,
                         dryRun: parsed.dryRun,
@@ -491,7 +522,10 @@ export const MagiPlugin = async ({ client, directory }) => {
                         pr,
                         parentSessionId: context.sessionID,
                         signal: context.abort,
+                        sync,
                     }), { signal: context.abort });
+                    if (sync)
+                        return syncResult(runManager, states);
                     return states
                         .map((state) => `Started reviewing ${prMarkdownLink(repository, state.pr)}.`)
                         .join("\n");
@@ -502,6 +536,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                 args: {
                     issues: tool.schema.string(),
                     dryRun: tool.schema.boolean().optional(),
+                    sync: tool.schema.boolean().optional(),
                 },
                 async execute(args, context) {
                     const parsed = parseIssueRunArguments(args.issues, args.dryRun ?? false);
@@ -523,6 +558,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                     const repository = resolveRepository(config);
                     if (!repository.triage)
                         return JSON.stringify({ errors: ["triage configuration is required"], ok: false }, null, 2);
+                    const sync = parsed.sync || args.sync === true;
                     const states = await mapPool(parsed.issues, repository.triage.concurrency.runs, (issue) => runManager.startTriage({
                         config,
                         dryRun: parsed.dryRun,
@@ -530,7 +566,10 @@ export const MagiPlugin = async ({ client, directory }) => {
                         parentSessionId: context.sessionID,
                         repository,
                         signal: context.abort,
+                        sync,
                     }), { signal: context.abort });
+                    if (sync)
+                        return syncResult(runManager, states);
                     return states
                         .map((state) => `Started triaging ${issueMarkdownLink(repository, state.issue)}.`)
                         .join("\n");

package/dist/orchestrator/run-manager.js

@@ -15,6 +15,7 @@ const DEFAULT_CLEAR_OPTIONS = {
     session: true,
     worktree: true,
 };
+const SYNC_RUN_TIMEOUT_MS = 600_000;
 function createRunId() {
     return `run-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
 }
@@ -453,11 +454,14 @@ 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) => {
+        });
+        if (input.sync)
+            return this.executeSync(state, controller, execute);
+        void execute().catch(async (error) => {
             await this.failRun(runId, error);
         });
         return state;
@@ -511,11 +515,14 @@ 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) => {
+        });
+        if (input.sync)
+            return this.executeSync(state, controller, execute);
+        void execute().catch(async (error) => {
             await this.failRun(runId, error);
         });
         return state;
@@ -568,11 +575,14 @@ 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) => {
+        });
+        if (input.sync)
+            return this.executeSync(state, controller, execute);
+        void execute().catch(async (error) => {
             await this.failRun(runId, error);
         });
         return state;
@@ -1210,6 +1220,36 @@ export class MagiRunManager {
     hasBlockedAgents(state) {
         return this.agentEntries(state).some(([, agent]) => agent.status === "blocked");
     }
+    async executeSync(state, controller, execute) {
+        let timeout;
+        const timeoutPromise = new Promise((resolve) => {
+            timeout = setTimeout(() => resolve("timeout"), SYNC_RUN_TIMEOUT_MS);
+        });
+        try {
+            const result = await Promise.race([
+                execute().then(() => "completed"),
+                timeoutPromise,
+            ]);
+            if (result === "timeout") {
+                controller.abort();
+                await this.failRun(state.runId, new Error("Magi sync run timed out after 600 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,
@@ -1347,24 +1387,30 @@ 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,
             });
+            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,
             });
+            if (input.sync)
+                this.assertSuccessfulSyncFollowUp(followUp);
         }
         this.active.delete(input.runId);
         this.controllers.delete(input.runId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-magi",
-  "version": "0.0.0-dev-20260521143330",
+  "version": "0.0.0-dev-20260521143913",
   "description": "Multi-agent PR review and merge orchestration plugin for OpenCode.",
   "license": "MIT",
   "author": "Hirotomo Yamada <hirotomo.yamada@avap.co.jp>",