@unlinearity/cli-wechat-bridge 1.2.1 → 1.2.3

package/dist/bridge/bridge-adapters.opencode.js

@@ -4,6 +4,7 @@
 // This file is part of CLI-WeChat-Bridge. Modifications and derivative works
 // must be released under AGPL-3.0-or-later with full source code; see
 // LICENSE.txt. Network services built on it must offer source to users.
+import { t } from "../i18n/index.js";
 import { spawn as spawnChildProcess } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import fs from "node:fs";
@@ -97,8 +98,14 @@ export class OpenCodeServerAdapter {
     lastMirroredLocalPrompt = null;
     pendingLocalSessionCreateFollowUntilMs = 0;
     pendingPermission = null;
+    pendingPermissions = new Map();
+    approvalOwnershipGeneration = 0;
+    settledPermissionIds = new Set();
+    resolvingPermissions = new Set();
+    childSessionParents = new Map();
     pendingQuestion = null;
     previousAgentBySession = new Map();
+    childSessionIds = new Set();
     async listModels() {
         this.assertRemoteControlReady();
         const session = await this.ensureControlSession();
@@ -116,7 +123,7 @@ export class OpenCodeServerAdapter {
         const models = await this.listControlModels();
         const target = models.find((model) => model.id === modelId);
         if (!target) {
-            throw new Error("This OpenCode model is no longer available. Send /model again.");
+            throw new Error(t("adapter.opencode.modelUnavailable"));
         }
         const currentVariant = session.model?.variant;
         const variant = currentVariant && currentVariant !== "default" && target.variants.includes(currentVariant)
@@ -136,7 +143,7 @@ export class OpenCodeServerAdapter {
             updated.model?.providerID !== target.providerID ||
             updated.model.id !== target.modelID ||
             (updated.model.variant ?? "default") !== variant) {
-            throw new Error("OpenCode did not confirm the selected model.");
+            throw new Error(t("adapter.opencode.modelUnconfirmed"));
         }
         return { id: target.id, displayName: target.displayName, isCurrent: true };
     }
@@ -146,11 +153,11 @@ export class OpenCodeServerAdapter {
         const agents = await this.listPrimaryAgents();
         const planAgent = agents.find((agent) => agent.name === "plan");
         if (!planAgent) {
-            throw new Error("OpenCode primary agent 'plan' is not available.");
+            throw new Error(t("adapter.opencode.planUnavailable"));
         }
         const currentAgent = session.agent ?? agents[0]?.name;
         if (!currentAgent) {
-            throw new Error("OpenCode did not return any primary agents.");
+            throw new Error(t("adapter.opencode.agentsMissing"));
         }
         if (enabled && currentAgent === "plan") {
             return true;
@@ -167,7 +174,7 @@ export class OpenCodeServerAdapter {
                 : agents.find((agent) => agent.name === "build")?.name ??
                     agents.find((agent) => agent.name !== "plan")?.name;
         if (!target) {
-            throw new Error("OpenCode did not return an agent that can replace plan mode.");
+            throw new Error(t("adapter.opencode.planReplacementMissing"));
         }
         const result = await this.client.v2.session.switchAgent({
             sessionID: session.id,
@@ -176,7 +183,7 @@ export class OpenCodeServerAdapter {
         this.unwrapOrThrow(result);
         const updated = await this.getSessionForCurrentDirectory(session.id);
         if (!updated || updated.agent !== target) {
-            throw new Error("OpenCode did not confirm the selected agent.");
+            throw new Error(t("adapter.opencode.agentUnconfirmed"));
         }
         if (enabled) {
             this.previousAgentBySession.set(session.id, currentAgent);
@@ -188,16 +195,16 @@ export class OpenCodeServerAdapter {
     }
     assertRemoteControlReady() {
         if (!this.client) {
-            throw new Error("OpenCode is not running.");
+            throw new Error(t("adapter.opencode.notRunning"));
         }
         if (this.state.status === "busy") {
-            throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
+            throw new Error(t("adapter.opencode.busy"));
         }
         if (this.pendingPermission) {
-            throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.opencode.approvalPending"));
         }
         if (this.pendingQuestion) {
-            throw new Error("OpenCode is waiting for user input. Reply with /answer or use /stop.");
+            throw new Error(t("adapter.opencode.inputPending"));
         }
     }
     async ensureControlSession() {
@@ -214,7 +221,7 @@ export class OpenCodeServerAdapter {
     }
     async listPrimaryAgents() {
         if (!this.client)
-            throw new Error("OpenCode is not running.");
+            throw new Error(t("adapter.opencode.notRunning"));
         const agents = this.unwrapOrThrow(await this.client.app.agents({
             directory: this.options.cwd,
             workspace: this.activeWorkspaceId ?? undefined,
@@ -223,7 +230,7 @@ export class OpenCodeServerAdapter {
     }
     async listControlModels() {
         if (!this.client)
-            throw new Error("OpenCode is not running.");
+            throw new Error(t("adapter.opencode.notRunning"));
         const providers = this.unwrapOrThrow(await this.client.provider.list({ directory: this.options.cwd, workspace: this.activeWorkspaceId ?? undefined }, { signal: AbortSignal.timeout(10_000) }));
         return providers.all.filter((provider) => providers.connected.includes(provider.id)).flatMap((provider) => Object.entries(provider.models).filter(([id, model]) => model.status !== "deprecated" && !(provider.id === "opencode" && id.includes("-nano"))).map(([id, model]) => ({
             id: `${provider.id}/${id}`, displayName: `${model.name || id} (${provider.name})`,
@@ -236,6 +243,8 @@ export class OpenCodeServerAdapter {
         this.state = {
             kind: options.kind,
             status: "stopped",
+            supportsApprovalRequestIds: true,
+            pendingApprovals: [],
             cwd: options.cwd,
             command: options.command,
             profile: options.profile,
@@ -290,16 +299,16 @@ export class OpenCodeServerAdapter {
     }
     async sendInput(text) {
         if (!this.client) {
-            throw new Error("OpenCode adapter is not running.");
+            throw new Error(t("adapter.opencode.adapterNotRunning"));
         }
         if (this.state.status === "busy") {
-            throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
+            throw new Error(t("adapter.opencode.busy"));
         }
         if (this.pendingPermission) {
-            throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.opencode.approvalPending"));
         }
         if (this.pendingQuestion) {
-            throw new Error("OpenCode is waiting for user input. Reply with /answer or use /stop.");
+            throw new Error(t("adapter.opencode.inputPending"));
         }
         const normalized = normalizeOutput(text).trim();
         if (!normalized) {
@@ -349,7 +358,7 @@ export class OpenCodeServerAdapter {
     }
     async listResumeSessions(limit = 10) {
         if (!this.client) {
-            throw new Error("OpenCode is not running yet.");
+            throw new Error(t("adapter.opencode.notReady"));
         }
         try {
             const sessions = this.unwrapOrThrow(await this.client.session.list({
@@ -385,16 +394,16 @@ export class OpenCodeServerAdapter {
     }
     async resumeSession(sessionId) {
         if (!this.client) {
-            throw new Error("OpenCode is not running yet.");
+            throw new Error(t("adapter.opencode.notReady"));
         }
         if (this.pendingPermission) {
-            throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.opencode.approvalPending"));
         }
         if (this.pendingQuestion) {
-            throw new Error("OpenCode is waiting for user input. Reply with /answer or use /stop.");
+            throw new Error(t("adapter.opencode.inputPending"));
         }
         if (this.state.status === "busy") {
-            throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
+            throw new Error(t("adapter.opencode.busy"));
         }
         if (this.state.status !== "idle") {
             throw new Error(`OpenCode cannot switch sessions while its status is ${this.state.status}.`);
@@ -422,16 +431,16 @@ export class OpenCodeServerAdapter {
     }
     async createSession() {
         if (!this.client) {
-            throw new Error("OpenCode adapter is not running.");
+            throw new Error(t("adapter.opencode.adapterNotRunning"));
         }
         if (this.state.status === "busy") {
-            throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
+            throw new Error(t("adapter.opencode.busy"));
         }
         if (this.pendingPermission) {
-            throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.opencode.approvalPending"));
         }
         if (this.pendingQuestion) {
-            throw new Error("OpenCode is waiting for user input. Reply with /answer or use /stop.");
+            throw new Error(t("adapter.opencode.inputPending"));
         }
         this.outputBatcher.clear();
         this.clearStreamedPartState();
@@ -498,22 +507,30 @@ export class OpenCodeServerAdapter {
         await this.dispose();
         await this.start();
     }
-    async resolveApproval(action) {
-        if (!this.pendingPermission || !this.client) {
+    async resolveApproval(action, requestId) {
+        const pending = requestId === undefined
+            ? this.pendingPermission
+            : this.pendingPermissions.get(requestId);
+        if (!pending || !this.client || this.resolvingPermissions.has(pending.permissionId)) {
             return false;
         }
-        const { permissionId } = this.pendingPermission;
-        const response = action === "confirm" ? "once" : "reject";
+        this.resolvingPermissions.add(pending.permissionId);
         try {
             const result = await this.client.permission.reply({
-                requestID: permissionId,
+                requestID: pending.permissionId,
+                sessionID: pending.sessionId,
                 directory: this.options.cwd,
                 workspace: this.activeWorkspaceId ?? undefined,
-                reply: response,
+                reply: action === "confirm" ? "once" : "reject",
             });
             if (result.error !== undefined) {
                 throw new Error(`SDK error: ${describeUnknownError(result.error)}`);
             }
+            this.rememberSettledPermission(pending.permissionId);
+            this.pendingPermissions.delete(pending.permissionId);
+            this.clearWechatWorkingNotice();
+            this.syncPendingPermissions();
+            return true;
         }
         catch (err) {
             this.emit({
@@ -523,14 +540,17 @@ export class OpenCodeServerAdapter {
             });
             return false;
         }
-        this.clearWechatWorkingNotice();
-        this.clearPendingPermissionState();
-        this.setStatus("busy");
-        return true;
+        finally {
+            this.resolvingPermissions.delete(pending.permissionId);
+        }
     }
     async resolveAllApprovals(action) {
-        const ok = await this.resolveApproval(action);
-        return ok ? 1 : 0;
+        let count = 0;
+        for (const id of Array.from(this.pendingPermissions.keys())) {
+            if (await this.resolveApproval(action, id))
+                count++;
+        }
+        return count;
     }
     async submitUserInput(answers) {
         if (!this.pendingQuestion || !this.client) {
@@ -558,11 +578,14 @@ export class OpenCodeServerAdapter {
             return false;
         }
         this.clearPendingQuestionState();
-        this.setStatus("busy", "OpenCode user input submitted.");
+        this.setStatus(this.pendingPermissions.size ? "awaiting_approval" : "busy", "OpenCode user input submitted.");
         return true;
     }
     async dispose() {
         this.shuttingDown = true;
+        this.childSessionIds.clear();
+        this.childSessionParents.clear();
+        this.settledPermissionIds.clear();
         this.clearWechatWorkingNotice(true);
         this.pendingLocalPrompt = "";
         this.localPromptNoticeSent = false;
@@ -1355,6 +1378,10 @@ export class OpenCodeServerAdapter {
             }
             // Note: only permission.asked exists in the OpenCode wire protocol;
             // permission.updated was never emitted by the server.
+            case "permission.replied": {
+                this.handlePermissionSettled(payload);
+                return;
+            }
             case "permission.asked": {
                 this.handlePermissionRequest(payload);
                 return;
@@ -1416,7 +1443,6 @@ export class OpenCodeServerAdapter {
             case "session.diff":
             case "session.diff.delta":
             case "message.removed":
-            case "permission.replied":
             case "tui.toast.show":
                 return;
             default:
@@ -1523,7 +1549,17 @@ export class OpenCodeServerAdapter {
             return;
         }
         const sessionId = this.extractSessionId(properties);
-        if (sessionId && !this.syncTrackedSessionFromEvent(sessionId)) {
+        if (!sessionId)
+            return;
+        if (!this.isApprovalSessionOwned(sessionId)) {
+            const ownerSessionId = this.activeSessionId;
+            const generation = this.approvalOwnershipGeneration;
+            void this.discoverApprovalSessionOwnership(sessionId).then((owned) => {
+                if (owned && ownerSessionId === this.activeSessionId && generation === this.approvalOwnershipGeneration)
+                    this.handlePermissionRequest(properties);
+            }).catch((error) => {
+                this.logDebug(`[opencode-adapter:approval-owner] ${describeUnknownError(error)}`);
+            });
             return;
         }
         const pendingPermission = this.buildPendingPermission(properties);
@@ -1536,21 +1572,86 @@ export class OpenCodeServerAdapter {
             this.rejectPermission(pendingPermission, denyMessage);
             return;
         }
-        const approval = this.toPendingApproval(pendingPermission);
-        this.pendingPermission = pendingPermission;
-        this.state.pendingApproval = approval;
-        this.state.pendingApprovalOrigin = this.state.activeTurnOrigin;
-        this.setStatus("awaiting_approval", "OpenCode approval is required.");
-        this.emit({
-            type: "approval_required",
-            request: approval,
-            timestamp: nowIso(),
-        });
+        if (this.pendingPermissions.has(pendingPermission.permissionId) || this.settledPermissionIds.has(pendingPermission.permissionId))
+            return;
+        this.pendingPermissions.set(pendingPermission.permissionId, pendingPermission);
+        this.syncPendingPermissions();
+    }
+    isApprovalSessionOwned(sessionId) {
+        const seen = new Set();
+        let current = sessionId;
+        while (current && !seen.has(current)) {
+            if (current === this.activeSessionId)
+                return true;
+            seen.add(current);
+            current = this.childSessionParents.get(current);
+        }
+        return false;
+    }
+    async discoverApprovalSessionOwnership(sessionId, seen = new Set()) {
+        if (this.isApprovalSessionOwned(sessionId))
+            return true;
+        if (seen.has(sessionId) || seen.size >= 32 || !this.client?.session?.get)
+            return false;
+        seen.add(sessionId);
+        const result = await this.client.session.get({ sessionID: sessionId, directory: this.options.cwd });
+        const session = result.data;
+        if (!session || !this.isCurrentDirectorySession(session) || !session.parentID)
+            return false;
+        this.childSessionIds.add(sessionId);
+        if (!await this.discoverApprovalSessionOwnership(session.parentID, seen))
+            return false;
+        this.childSessionParents.set(sessionId, session.parentID);
+        return this.isApprovalSessionOwned(sessionId);
+    }
+    rememberSettledPermission(id) {
+        this.settledPermissionIds.add(id);
+        if (this.settledPermissionIds.size > 512) {
+            this.settledPermissionIds.delete(this.settledPermissionIds.values().next().value);
+        }
+    }
+    handlePermissionSettled(properties) {
+        if (!isRecord(properties))
+            return;
+        const id = typeof properties.requestID === "string" ? properties.requestID : properties.id;
+        if (typeof id !== "string")
+            return;
+        const pending = this.pendingPermissions.get(id);
+        if (!pending) {
+            this.rememberSettledPermission(id);
+            return;
+        }
+        if (typeof properties.sessionID === "string" && properties.sessionID !== pending.sessionId)
+            return;
+        this.rememberSettledPermission(id);
+        this.pendingPermissions.delete(id);
+        this.syncPendingPermissions();
+    }
+    syncPendingPermissions() {
+        const previousId = this.state.pendingApproval?.requestId;
+        this.pendingPermission = this.pendingPermissions.values().next().value ?? null;
+        const requests = Array.from(this.pendingPermissions.values(), (pending) => this.toPendingApproval(pending));
+        this.state.pendingApprovals = requests;
+        this.state.pendingApproval = requests[0] ?? null;
+        this.state.pendingApprovalOrigin = this.pendingPermission?.origin;
+        this.setStatus(requests.length ? "awaiting_approval" : this.state.pendingUserInput ? "awaiting_input" : "busy");
+        this.emit({ type: "approval_state_changed", requests, timestamp: nowIso() });
+        if (requests[0] && requests[0].requestId !== previousId) {
+            this.emit({ type: "approval_required", request: requests[0], timestamp: nowIso() });
+        }
     }
     clearPendingPermissionState() {
+        this.approvalOwnershipGeneration++;
+        const hadPending = this.pendingPermissions.size > 0;
+        for (const id of this.pendingPermissions.keys())
+            this.rememberSettledPermission(id);
+        this.pendingPermissions.clear();
         this.pendingPermission = null;
         this.state.pendingApproval = null;
+        this.state.pendingApprovals = [];
         this.state.pendingApprovalOrigin = undefined;
+        if (hadPending)
+            this.emit({ type: "approval_state_changed", requests: [], timestamp: nowIso() });
     }
     handleQuestionAsked(properties) {
         if (!isRecord(properties) || !this.client) {
@@ -1599,7 +1700,7 @@ export class OpenCodeServerAdapter {
             return;
         }
         const request = {
-            summary: `OpenCode requested answers to ${questions.length} question${questions.length === 1 ? "" : "s"}.`,
+            summary: t("input.request.opencode", { count: questions.length, questions: t(questions.length === 1 ? "input.request.singular" : "input.request.plural") }),
             questions,
         };
         this.pendingQuestion = {
@@ -1610,7 +1711,7 @@ export class OpenCodeServerAdapter {
         this.state.pendingUserInput = request;
         this.state.pendingUserInputOrigin = this.state.activeTurnOrigin;
         this.clearWechatWorkingNotice();
-        this.setStatus("awaiting_input", "OpenCode is waiting for user input.");
+        this.setStatus(this.pendingPermissions.size ? "awaiting_approval" : "awaiting_input", "OpenCode is waiting for user input.");
         this.emit({
             type: "user_input_required",
             request,
@@ -1693,6 +1794,7 @@ export class OpenCodeServerAdapter {
             try {
                 const result = await client.permission.reply({
                     requestID: pendingPermission.permissionId,
+                    sessionID: pendingPermission.sessionId,
                     directory: this.options.cwd,
                     workspace: this.activeWorkspaceId ?? undefined,
                     reply: "reject",
@@ -1736,12 +1838,14 @@ export class OpenCodeServerAdapter {
         const metadata = isRecord(properties.metadata) ? properties.metadata : {};
         const command = this.extractPermissionCommand(properties, metadata);
         return {
+            origin: this.state.activeTurnOrigin,
             sessionId,
             permissionId,
             code: buildOneTimeCode(),
             createdAt: nowIso(),
             request: {
                 source: "cli",
+                requestId: permissionId,
                 summary: title ?? `OpenCode needs approval${toolName ? ` for tool: ${toolName}` : ""}.`,
                 commandPreview: truncatePreview(command ?? title ?? "Permission request", 180),
                 toolName,
@@ -1777,6 +1881,17 @@ export class OpenCodeServerAdapter {
             return;
         }
         const session = this.extractSessionReference(properties);
+        if (session?.parentID) {
+            // Subagent creation is not a visible TUI selection. Remember the child
+            // so its later status/output events cannot implicitly follow it either.
+            this.childSessionIds.add(session.id);
+            const directory = this.extractSessionDirectory(properties);
+            if ((!directory || this.normalizeDirectory(directory) === this.normalizeDirectory(this.options.cwd))
+                && (!session.workspaceID || !this.activeWorkspaceId || session.workspaceID === this.activeWorkspaceId)) {
+                this.childSessionParents.set(session.id, session.parentID);
+            }
+            return;
+        }
         if (this.syncTrackedSessionFromEvent(session)) {
             return;
         }
@@ -1802,6 +1917,31 @@ export class OpenCodeServerAdapter {
         if (!sessionId) {
             return;
         }
+        const removedSessions = new Set([sessionId]);
+        let expanded = true;
+        while (expanded) {
+            expanded = false;
+            for (const [child, parent] of this.childSessionParents) {
+                if (removedSessions.has(parent) && !removedSessions.has(child)) {
+                    removedSessions.add(child);
+                    expanded = true;
+                }
+            }
+        }
+        for (const id of removedSessions) {
+            this.childSessionIds.delete(id);
+            this.childSessionParents.delete(id);
+        }
+        let removedApproval = false;
+        for (const [id, pending] of this.pendingPermissions) {
+            if (removedSessions.has(pending.sessionId)) {
+                this.rememberSettledPermission(id);
+                this.pendingPermissions.delete(id);
+                removedApproval = true;
+            }
+        }
+        if (removedApproval)
+            this.syncPendingPermissions();
         this.previousAgentBySession.delete(sessionId);
         if (sessionId !== this.activeSessionId) {
             return;
@@ -2592,6 +2732,9 @@ export class OpenCodeServerAdapter {
             this.assignActiveSession(session);
             return true;
         }
+        if (this.childSessionIds.has(sessionId)) {
+            return false;
+        }
         if (options.allowLocalTurnFollow !== false && this.shouldFollowLocalTurnSession(sessionId)) {
             this.switchSharedSession(session ?? sessionId, {
                 source: "local",
@@ -2604,6 +2747,9 @@ export class OpenCodeServerAdapter {
         return false;
     }
     extractSessionReference(properties) {
+        const session = isRecord(properties.session) ? properties.session : undefined;
+        const info = isRecord(properties.info) ? properties.info : undefined;
+        const parentID = [properties.parentID, session?.parentID, info?.parentID].find((value) => typeof value === "string" && value.length > 0);
         if (typeof properties.sessionID === "string" || typeof properties.sessionId === "string") {
             const id = typeof properties.sessionID === "string"
                 ? properties.sessionID
@@ -2611,20 +2757,21 @@ export class OpenCodeServerAdapter {
             return {
                 id,
                 workspaceID: this.extractWorkspaceId(properties) ?? undefined,
+                parentID,
             };
         }
-        const session = isRecord(properties.session) ? properties.session : undefined;
         if (typeof session?.id === "string") {
             return {
                 id: session.id,
                 workspaceID: this.extractWorkspaceId(session) ?? this.extractWorkspaceId(properties) ?? undefined,
+                parentID,
             };
         }
-        const info = isRecord(properties.info) ? properties.info : undefined;
         if (typeof info?.id === "string") {
             return {
                 id: info.id,
                 workspaceID: this.extractWorkspaceId(info) ?? this.extractWorkspaceId(properties) ?? undefined,
+                parentID,
             };
         }
         return null;
@@ -2670,7 +2817,7 @@ export class OpenCodeServerAdapter {
             return false;
         }
         const session = this.extractSessionReference(payload);
-        if (!session?.id || session.id === this.activeSessionId) {
+        if (!session?.id || session.parentID || session.id === this.activeSessionId) {
             return false;
         }
         if (typeof event.directory === "string" ||