opencode-magi 0.0.0-dev-20260714091053 → 0.0.0-dev-20260715023915

package/dist/magi.js

@@ -33,7 +33,7 @@ export class Magi {
         return this.exec(command("gh", "auth", "token", account && "--user", account && quote(account)), { signal });
     }
     async createOctokit(config, signal, account) {
-        const auth = await this.getGhToken(account);
+        const auth = await this.getGhToken(account, signal);
         const retries = config.github.retryApiAttempts;
         return new Octokit({
             auth,
@@ -187,7 +187,7 @@ export class Magi {
             ...filterEmpty(this.getAgents(state).map(({ sessionId }) => sessionId)),
         ];
     }
-    async createSession(parentID, title, { model, permissions, }) {
+    async createSession(parentID, title, { model, permissions, }, signal) {
         if (isArray(model) || !isObject(model))
             throw new Error();
         const { id, variant } = model;
@@ -201,7 +201,7 @@ export class Magi {
             parentID,
             permission: resolvePermissions(permissions),
             title,
-        });
+        }, { signal });
         if (result.error) {
             throw new Error(result.response.statusText);
         }
@@ -210,11 +210,11 @@ export class Magi {
             return id;
         }
     }
-    async promptSession(sessionID, text) {
+    async promptSession(sessionID, text, signal) {
         const result = await this.input.client.session.prompt({
             parts: [{ text, type: "text" }],
             sessionID,
-        });
+        }, { signal });
         if (result.error) {
             throw new Error(result.response.statusText);
         }

package/dist/tools/merge/action.js

@@ -15,6 +15,7 @@ export async function editCycles(callback) {
             await this.updateEvent(`Attempt ${count} failed to edit cycles. Retrying...`);
         },
         retries: this.config.merge.maxThreadResolutionCycles,
+        signal: this.context.abort,
     });
     if (!verdict || verdict === "CHANGES_REQUESTED")
         throw new MagiError("blocked", `Reached maximum edit cycles.`);

package/dist/tools/merge/editor.js

@@ -25,7 +25,7 @@ export async function edit() {
     });
     const repairMessage = await prompt.repair();
     const output = await retry(async (count) => {
-        const raw = await this.magi.promptSession(this.state.editor.sessionId, count === 1 ? taskMessage : repairMessage);
+        const raw = await this.magi.promptSession(this.state.editor.sessionId, count === 1 ? taskMessage : repairMessage, this.context.abort);
         await this.createAgentFile("edit", "editor", raw, count, cycle);
         const parsed = prompt.parse(raw);
         if (!prompt.validate(parsed))
@@ -46,6 +46,7 @@ export async function edit() {
     }, {
         error: (_, count) => this.updateEvent(`Attempt ${count} failed to edit. Retrying...`),
         retries: this.config.output.repairAttempts,
+        signal: this.context.abort,
     });
     if (!output)
         throw new MagiError("blocked", "Invalid output for editor.");
@@ -112,7 +113,7 @@ export async function resolveConflict() {
     });
     const repairMessage = await prompt.repair();
     const output = await retry(async (count) => {
-        const raw = await this.magi.promptSession(this.state.editor.sessionId, count === 1 ? taskMessage : repairMessage);
+        const raw = await this.magi.promptSession(this.state.editor.sessionId, count === 1 ? taskMessage : repairMessage, this.context.abort);
         await this.createAgentFile("conflict", "editor", raw, count, cycle);
         const parsed = prompt.parse(raw);
         if (!prompt.validate(parsed))
@@ -137,6 +138,7 @@ export async function resolveConflict() {
     }, {
         error: (_, count) => this.updateEvent(`Attempt ${count} failed to resolve conflicts. Retrying...`),
         retries: this.config.output.repairAttempts,
+        signal: this.context.abort,
     });
     if (!output)
         throw new MagiError("blocked", "Invalid output for conflict editor.");
@@ -181,7 +183,7 @@ async function push() {
         throw new MagiError("blocked", "PR metadata not found.");
     if (!this.state.worktree)
         throw new MagiError("blocked", "PR worktree not found.");
-    const token = await this.magi.getGhToken(this.state.editor.account);
+    const token = await this.magi.getGhToken(this.state.editor.account, this.context.abort);
     const url = `https://${this.config.github.host}/${this.state.pr.metadata.head.repo.owner.login}/${this.state.pr.metadata.head.repo.name}.git`;
     const ref = `HEAD:refs/heads/${this.state.pr.metadata.head.ref}`;
     await this.exec(command("git", "push", quote(url), quote(ref)), {

package/dist/tools/merge/merge.js

@@ -1,38 +1,21 @@
 import { join } from "node:path";
 import { MagiError } from "@/magi";
 import { Review } from "@/tools/review/review";
-import { createExecWithGitHubApiRetry, quote } from "@/utils";
 import { editCycles, postReplies } from "./action";
 import { fetchMergeContext, markRepliedReviewers } from "./context";
 import { edit, resolveConflict } from "./editor";
 import { createReport } from "./report";
 export class Merge extends Review {
     static async init(number, magi, config, context, options) {
-        const url = `${config.github.url}/pull/${number}`;
-        const octokit = await magi.createOctokit(config, context.abort);
-        const graphql = magi.createGraphql(octokit);
-        const reviewers = Object.fromEntries(config.review.reviewers.map(({ account, id, model, permissions }) => [id, { account, model, permissions }]));
-        const operator = config.review.operator
-            ? config.review.reviewers.find(({ id }) => id === config.review.operator)
-            : config.review.reviewers[Math.abs(number) % config.review.reviewers.length];
+        const { exec, graphql, octokit, ...rest } = await this.setup(number, magi, config, context);
         const editor = {
             account: config.merge.editor.account,
             author: config.merge.editor.author,
             model: config.merge.editor.model,
             permissions: config.merge.editor.permissions,
         };
-        const state = await magi.createState(join(config.review.output, number.toString()), {
-            ...options,
-            command: "merge",
-            editor,
-            operator,
-            pr: { number, url },
-            repo: quote(`${config.github.owner}/${config.github.repo}`),
-            reviewers,
-            sessionId: context.sessionID,
-        });
+        const state = await magi.createState(join(config.review.output, number.toString()), { ...options, ...rest, command: "merge", editor });
         await magi.updateEvent(state.output, `Started merging.`);
-        const exec = createExecWithGitHubApiRetry(magi.exec, config.github.retryApiAttempts);
         return new Merge(number, magi, config, context, octokit, graphql, exec, state);
     }
     createReport = createReport;
@@ -51,7 +34,7 @@ export class Merge extends Review {
             sessionId: await this.magi.createSession(this.state.sessionId, `magi merge #${this.number} editor`, {
                 model: this.state.editor.model,
                 permissions: this.state.editor.permissions,
-            }),
+            }, this.context.abort),
         };
         await this.updateState({ editor });
         await this.updateEvent(`Finished creating editor session.`);

package/dist/tools/merge/report.js

@@ -4,6 +4,7 @@ import { MagiError } from "@/magi";
 import { createCheckContent, createMetaContent, createReviewerContent, } from "@/tools/review/report";
 import { filterEmpty, toTitleCase } from "@/utils";
 export async function createReport(e) {
+    this.context.abort.throwIfAborted();
     if (!e) {
         const status = "completed";
         const text = await createContent.call(this, { status });

package/dist/tools/review/action.js

@@ -80,7 +80,7 @@ export async function postReviews() {
             });
             const repairMessage = await prompt.repair();
             const output = await retry(async (count) => {
-                const raw = await this.magi.promptSession(this.state.operator.sessionId, count === 1 ? taskMessage : repairMessage);
+                const raw = await this.magi.promptSession(this.state.operator.sessionId, count === 1 ? taskMessage : repairMessage, this.context.abort);
                 await this.createAgentFile("comment", "operator", raw, count);
                 const parsed = prompt.parse(raw);
                 if (!prompt.validate(parsed))
@@ -89,6 +89,7 @@ export async function postReviews() {
             }, {
                 error: (_, count) => this.updateEvent(`Attempt ${count} failed to post comment by operator. Retrying...`),
                 retries: this.config.output.repairAttempts,
+                signal: this.context.abort,
             });
             if (!output)
                 throw new MagiError("blocked", "Invalid output for operator.");
@@ -206,7 +207,7 @@ export async function automate() {
         await this.updateEvent(`Skipped ${action} automation during dry run.`);
         return "SKIPPED";
     }
-    const token = await this.magi.getGhToken(account);
+    const token = await this.magi.getGhToken(account, this.context.abort);
     if (action === "merge" && !this.config.review.merge.queue) {
         const rules = JSON.parse(await this.exec(command("gh", "api", quote(`repos/${this.config.github.owner}/${this.config.github.repo}/rules/branches/${this.state.pr.metadata.base.ref}`)), {
             env: { GH_TOKEN: token },
@@ -375,7 +376,7 @@ async function waitMergeQueue(leftMergeQueue = false) {
         }
         throw new MagiError("blocked", `PR left the merge queue before merging.`);
     }
-    await wait(30_000);
+    await wait(30_000, this.context.abort);
     return await waitMergeQueue.call(this, nextLeftMergeQueue);
 }
 async function isConflict() {

package/dist/tools/review/check.js

@@ -107,7 +107,7 @@ export async function classifyChecks() {
             throw new Error(`No session ID found for reviewer ${id}.`);
         await this.updateEvent(`Classifying CI checks with reviewer ${id}.`);
         const output = await retry(async (count) => {
-            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : repairMessage);
+            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : repairMessage, this.context.abort);
             await this.createAgentFile("ci-classification", id, raw, count);
             const parsed = prompt.parse(raw);
             if (!prompt.validate(parsed))
@@ -116,6 +116,7 @@ export async function classifyChecks() {
         }, {
             error: (_, count) => this.updateEvent(`Attempt ${count} failed to classify CI checks with reviewer ${id}. Retrying...`),
             retries: this.config.output.repairAttempts,
+            signal: this.context.abort,
         });
         if (!output)
             throw new MagiError("blocked", `Invalid output for reviewer ${id}.`);
@@ -201,6 +202,7 @@ export async function rerunChecks() {
         }, {
             error: (_, count) => this.updateEvent(`Attempt ${count} failed to rerun checks ${label}. Retrying...`),
             retries: this.config.review.checks.retryFailedJobs,
+            signal: this.context.abort,
         });
     }
     const passedChecksAfterRerun = checks.passed.filter((check) => "scope" in check && !check.scope);

package/dist/tools/review/report.js

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { MagiError } from "@/magi";
 import { filterEmpty, toTitleCase } from "@/utils";
 export async function createReport(e) {
+    this.context.abort.throwIfAborted();
     if (!e) {
         const status = "completed";
         const text = await createContent.call(this, { status });

package/dist/tools/review/review.js

@@ -27,6 +27,12 @@ export class Review {
         this.state = state;
     }
     static async init(number, magi, config, context, options) {
+        const { exec, graphql, octokit, ...rest } = await this.setup(number, magi, config, context);
+        const state = await magi.createState(join(config.review.output, number.toString()), { ...options, ...rest, command: "review" });
+        await magi.updateEvent(state.output, `Started reviewing.`);
+        return new Review(number, magi, config, context, octokit, graphql, exec, state);
+    }
+    static async setup(number, magi, config, context) {
         const url = `${config.github.url}/pull/${number}`;
         const octokit = await magi.createOctokit(config, context.abort);
         const graphql = magi.createGraphql(octokit);
@@ -34,18 +40,17 @@ export class Review {
         const operator = config.review.operator
             ? config.review.reviewers.find(({ id }) => id === config.review.operator)
             : config.review.reviewers[Math.abs(number) % config.review.reviewers.length];
-        const state = await magi.createState(join(config.review.output, number.toString()), {
-            ...options,
-            command: "review",
+        const exec = createExecWithGitHubApiRetry(magi.exec, config.github.retryApiAttempts);
+        return {
+            exec,
+            graphql,
+            octokit,
             operator,
             pr: { number, url },
             repo: quote(`${config.github.owner}/${config.github.repo}`),
             reviewers,
             sessionId: context.sessionID,
-        });
-        await magi.updateEvent(state.output, `Started reviewing.`);
-        const exec = createExecWithGitHubApiRetry(magi.exec, config.github.retryApiAttempts);
-        return new Review(number, magi, config, context, octokit, graphql, exec, state);
+        };
     }
     checkPr = checkPr;
     checkExistingReviews = checkExistingReviews;
@@ -60,6 +65,12 @@ export class Review {
     automate = automate;
     createReport = createReport;
     async cleanup() {
+        if (this.context.abort.aborted &&
+            ["preparing", "running"].includes(this.state.status))
+            await this.updateState({
+                completedAt: new Date().toISOString(),
+                status: "cancelled",
+            });
         if (this.state.worktree?.path)
             await this.magi.deleteWorktree(this.state.worktree.path);
     }
@@ -84,14 +95,14 @@ export class Review {
         const reviewers = Object.fromEntries(await Promise.all(Object.entries(this.state.reviewers).map(async ([id, { model, permissions }]) => [
             id,
             {
-                sessionId: await this.magi.createSession(this.state.sessionId, `magi review #${this.number} ${id}`, { model, permissions }),
+                sessionId: await this.magi.createSession(this.state.sessionId, `magi review #${this.number} ${id}`, { model, permissions }, this.context.abort),
             },
         ])));
         const operator = {
             sessionId: await this.magi.createSession(this.state.sessionId, `magi review #${this.number} operator`, {
                 model: this.state.operator.model,
                 permissions: this.state.operator.permissions,
-            }),
+            }, this.context.abort),
         };
         await this.updateState({ operator, reviewers });
     }

package/dist/tools/review/reviewer.js

@@ -96,7 +96,7 @@ export async function review() {
             }));
             const repairMessage = await prompt.repair();
             const output = await retry(async (count) => {
-                const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : repairMessage);
+                const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : repairMessage, this.context.abort);
                 await this.createAgentFile(rereview ? "rereview" : "review", id, raw, count, cycle);
                 const parsed = prompt.parse(raw);
                 if (!prompt.validate(parsed))
@@ -127,6 +127,7 @@ export async function review() {
             }, {
                 error: (_, count) => this.updateEvent(`Attempt ${count} failed to ${label} with reviewer ${id}. Retrying...`),
                 retries: this.config.output.repairAttempts,
+                signal: this.context.abort,
             });
             if (!output)
                 throw new MagiError("blocked", `Invalid output for reviewer ${id}.`);
@@ -200,7 +201,7 @@ export async function reconsiderClose() {
         const repairMessage = await prompt.repair();
         await this.updateEvent(`Reconsidering close verdict with reviewer ${id}.`);
         const output = await retry(async (count) => {
-            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : repairMessage);
+            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : repairMessage, this.context.abort);
             await this.createAgentFile("close-reconsideration", id, raw, count, cycle);
             const parsed = prompt.parse(raw);
             if (!prompt.validate(parsed))
@@ -210,6 +211,7 @@ export async function reconsiderClose() {
         }, {
             error: (_, count) => this.updateEvent(`Attempt ${count} failed to reconsider close verdict with reviewer ${id}. Retrying...`),
             retries: this.config.output.repairAttempts,
+            signal: this.context.abort,
         });
         if (!output)
             throw new MagiError("blocked", `Invalid close reconsideration output for reviewer ${id}.`);
@@ -266,7 +268,7 @@ async function collectAcceptedFindings(findings) {
         });
         const repairMessage = await prompt.repair();
         const output = await retry(async (count) => {
-            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : repairMessage);
+            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : repairMessage, this.context.abort);
             await this.createAgentFile("finding-validation", id, raw, count);
             const parsed = prompt.parse(raw);
             if (!prompt.validate(parsed))
@@ -289,6 +291,7 @@ async function collectAcceptedFindings(findings) {
         }, {
             error: (_, count) => this.updateEvent(`Attempt ${count} failed to validate review findings with reviewer ${id}. Retrying...`),
             retries: this.config.output.repairAttempts,
+            signal: this.context.abort,
         });
         if (!output)
             throw new MagiError("blocked", `Invalid finding validation output for reviewer ${id}.`);

package/dist/utils/function.js

@@ -1,6 +1,17 @@
-export const wait = async (ms = 0) => new Promise((resolve) => {
-    setTimeout(resolve, ms);
-});
+export function wait(ms = 0, signal) {
+    signal?.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            clearTimeout(timeout);
+            reject(signal?.reason);
+        };
+        const timeout = setTimeout(() => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", abort, { once: true });
+    });
+}
 export async function loop(callback, ms = 0) {
     for (;;) {
         const value = await callback();
@@ -9,13 +20,15 @@ export async function loop(callback, ms = 0) {
         await wait(ms);
     }
 }
-export async function retry(callback, { error, retries = 1 }) {
+export async function retry(callback, { error, retries = 1, signal }) {
     let count = 1;
     while (count <= retries)
         try {
+            signal?.throwIfAborted();
             return await callback(count);
         }
         catch (e) {
+            signal?.throwIfAborted();
             await error?.(e, count);
             count += 1;
         }

package/package.json

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