cli-wechat-bridge 1.1.1 → 1.1.3

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

@@ -1,5 +1,5 @@
 import { spawn as spawnChildProcess } from "node:child_process";
-import { OPENCODE_SERVER_HOST, OPENCODE_SERVER_READY_TIMEOUT_MS, OPENCODE_SSE_RECONNECT_DELAY_MS, OPENCODE_SESSION_IDLE_SETTLE_MS, OPENCODE_WECHAT_WORKING_NOTICE_DELAY_MS, buildCliEnvironment, isRecord, describeUnknownError, resolveSpawnTarget, reserveLocalPort, waitForTcpPort, delay, } from "./bridge-adapters.shared.js";
+import { OPENCODE_SERVER_HOST, OPENCODE_SERVER_READY_TIMEOUT_MS, OPENCODE_SSE_RECONNECT_DELAY_MS, OPENCODE_SESSION_IDLE_SETTLE_MS, OPENCODE_WECHAT_WORKING_NOTICE_DELAY_MS, OPENCODE_HTTP_READY_TIMEOUT_MS, OPENCODE_HTTP_READY_PROBE_TIMEOUT_MS, OPENCODE_HTTP_READY_PROBE_INTERVAL_MS, buildCliEnvironment, isRecord, describeUnknownError, resolveSpawnTarget, reserveLocalPort, waitForTcpPort, delay, } from "./bridge-adapters.shared.js";
 import { killProcessTreeSync } from "./bridge-process-reaper.js";
 import { WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE, buildOneTimeCode, isWechatOutboundAttachmentMutationTool, isWechatOutboundAttachmentWriteCommand, normalizeOutput, nowIso, truncatePreview, OutputBatcher, } from "./bridge-utils.js";
 const OPENCODE_DEBUG_ENABLED = /^(1|true|yes|on)$/i.test(process.env.WECHAT_OPENCODE_DEBUG ?? "");
@@ -8,6 +8,8 @@ const OPENCODE_WECHAT_MIRROR_SUPPRESSION_TTL_MS = 30_000;
 const OPENCODE_RECENT_LOCAL_PROMPT_TTL_MS = 10_000;
 const OPENCODE_LOCAL_SESSION_CREATE_FOLLOW_TTL_MS = 5_000;
 const OPENCODE_TUI_SELECT_RETRY_DELAYS_MS = [250, 750, 1_500];
+const OPENCODE_MINIMUM_SUPPORTED_VERSION = "1.18.0";
+const OPENCODE_MAXIMUM_SUPPORTED_MAJOR = 2;
 /* ------------------------------------------------------------------ */
 /*  Adapter                                                            */
 /* ------------------------------------------------------------------ */
@@ -31,6 +33,11 @@ export class OpenCodeServerAdapter {
     workingNoticeTimer = null;
     workingNoticeSent = false;
     lastBusyAtMs = 0;
+    // Monotonic token bumped on every beginTrackedTurn. Lets a deferred turn
+    // completion (.then in handleSessionIdle) detect that a newer turn started
+    // while it was awaiting, so the stale completion becomes a no-op instead of
+    // clobbering the in-flight turn (stale final_reply / status flip / batcher clear).
+    currentTurnToken = 0;
     pendingLocalPrompt = "";
     localPromptNoticeSent = false;
     loggedUnknownEventTypes = new Set();
@@ -48,6 +55,7 @@ export class OpenCodeServerAdapter {
     lastMirroredLocalPrompt = null;
     pendingLocalSessionCreateFollowUntilMs = 0;
     pendingPermission = null;
+    pendingQuestion = null;
     constructor(options) {
         this.options = options;
         this.state = {
@@ -112,6 +120,9 @@ export class OpenCodeServerAdapter {
         if (this.pendingPermission) {
             throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
         }
+        if (this.pendingQuestion) {
+            throw new Error("OpenCode is waiting for user input. Reply with /answer or use /stop.");
+        }
         const normalized = normalizeOutput(text).trim();
         if (!normalized) {
             return;
@@ -165,6 +176,9 @@ export class OpenCodeServerAdapter {
         if (this.pendingPermission) {
             throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
         }
+        if (this.pendingQuestion) {
+            throw new Error("OpenCode is waiting for user input. Reply with /answer or use /stop.");
+        }
         this.outputBatcher.clear();
         this.clearStreamedPartState();
         const session = this.unwrapOrThrow(await this.client.session.create({
@@ -185,10 +199,16 @@ export class OpenCodeServerAdapter {
         if (!this.client || !this.activeSessionId) {
             return false;
         }
-        if (this.state.status !== "busy" && this.state.status !== "awaiting_approval") {
+        if (this.state.status !== "busy" &&
+            this.state.status !== "awaiting_approval" &&
+            this.state.status !== "awaiting_input") {
             return false;
         }
         this.clearWechatWorkingNotice(true);
+        if (this.pendingQuestion) {
+            await this.rejectPendingQuestion(this.pendingQuestion);
+            this.clearPendingQuestionState();
+        }
         try {
             await this.client.session.abort({
                 sessionID: this.activeSessionId,
@@ -209,6 +229,7 @@ export class OpenCodeServerAdapter {
         this.clearObservedMessageTracking();
         this.recentSdkEventObservations.clear();
         this.clearPendingPermissionState();
+        this.clearPendingQuestionState();
         this.activeSessionId = null;
         this.state.sharedSessionId = undefined;
         this.state.sharedThreadId = undefined;
@@ -227,15 +248,14 @@ export class OpenCodeServerAdapter {
         if (!this.pendingPermission || !this.client) {
             return false;
         }
-        const { sessionId, permissionId } = this.pendingPermission;
+        const { permissionId } = this.pendingPermission;
         const response = action === "confirm" ? "once" : "reject";
         try {
-            const result = await this.client.permission.respond({
-                sessionID: sessionId,
-                permissionID: permissionId,
+            const result = await this.client.permission.reply({
+                requestID: permissionId,
                 directory: this.options.cwd,
                 workspace: this.activeWorkspaceId ?? undefined,
-                response,
+                reply: response,
             });
             if (result.error !== undefined) {
                 throw new Error(`SDK error: ${describeUnknownError(result.error)}`);
@@ -258,8 +278,34 @@ export class OpenCodeServerAdapter {
         const ok = await this.resolveApproval(action);
         return ok ? 1 : 0;
     }
-    async submitUserInput(_answers) {
-        return false;
+    async submitUserInput(answers) {
+        if (!this.pendingQuestion || !this.client) {
+            return false;
+        }
+        const pending = this.pendingQuestion;
+        const orderedAnswers = pending.request.questions.map((question) => answers[question.id] ?? []);
+        try {
+            const result = await this.client.question.reply({
+                requestID: pending.requestId,
+                directory: this.options.cwd,
+                workspace: this.activeWorkspaceId ?? undefined,
+                answers: orderedAnswers,
+            });
+            if (result.error !== undefined) {
+                throw new Error(`SDK error: ${describeUnknownError(result.error)}`);
+            }
+        }
+        catch (err) {
+            this.emit({
+                type: "stderr",
+                text: `Failed to submit OpenCode user input: ${describeUnknownError(err)}`,
+                timestamp: nowIso(),
+            });
+            return false;
+        }
+        this.clearPendingQuestionState();
+        this.setStatus("busy", "OpenCode user input submitted.");
+        return true;
     }
     async dispose() {
         this.shuttingDown = true;
@@ -272,6 +318,7 @@ export class OpenCodeServerAdapter {
         this.outputBatcher.clear();
         this.clearStreamedPartState();
         this.clearPendingPermissionState();
+        this.clearPendingQuestionState();
         // Stop SSE listener
         if (this.sseAbortController) {
             this.sseAbortController.abort();
@@ -453,10 +500,54 @@ export class OpenCodeServerAdapter {
     }
     async checkHealth() {
         const baseUrl = `http://${OPENCODE_SERVER_HOST}:${this.serverPort}`;
-        const response = await fetch(`${baseUrl}/session/status`);
-        if (!response.ok) {
-            throw new Error(`OpenCode health check failed (HTTP ${response.status}).`);
+        // `opencode serve` binds its TCP port before the HTTP layer is ready,
+        // so a fetch fired the instant `waitForTcpPort` returns can be accepted
+        // into the listen backlog but never answered, hanging until undici's
+        // ~300s `headersTimeout` and surfacing as `fetch failed` after ~5min.
+        // Retry with a short per-attempt timeout so the startup race
+        // self-heals once the server finishes booting.
+        const deadline = Date.now() + OPENCODE_HTTP_READY_TIMEOUT_MS;
+        let lastError;
+        while (Date.now() < deadline) {
+            try {
+                const response = await fetch(`${baseUrl}/global/health`, {
+                    signal: AbortSignal.timeout(OPENCODE_HTTP_READY_PROBE_TIMEOUT_MS),
+                });
+                if (response.ok) {
+                    const health = await response.json();
+                    if (!isRecord(health) || health.healthy !== true || typeof health.version !== "string") {
+                        lastError = new Error("OpenCode health check returned an invalid response.");
+                    }
+                    else if (!this.isSupportedOpenCodeVersion(health.version)) {
+                        throw new Error(`Unsupported OpenCode version ${health.version}. Install OpenCode >=${OPENCODE_MINIMUM_SUPPORTED_VERSION} <${OPENCODE_MAXIMUM_SUPPORTED_MAJOR}.0.0.`);
+                    }
+                    else {
+                        return;
+                    }
+                }
+                else {
+                    lastError = new Error(`OpenCode health check failed (HTTP ${response.status}).`);
+                }
+            }
+            catch (err) {
+                if (err instanceof Error &&
+                    err.message.startsWith("Unsupported OpenCode version ")) {
+                    throw err;
+                }
+                lastError = err;
+            }
+            await delay(OPENCODE_HTTP_READY_PROBE_INTERVAL_MS);
         }
+        throw lastError ?? new Error("OpenCode health check timed out.");
+    }
+    isSupportedOpenCodeVersion(version) {
+        const match = /^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version.trim());
+        if (!match) {
+            return false;
+        }
+        const major = Number(match[1]);
+        const minor = Number(match[2]);
+        return major === 1 && minor >= 18;
     }
     async initializeSessions() {
         if (!this.client) {
@@ -563,11 +654,11 @@ export class OpenCodeServerAdapter {
             return;
         }
         this.sseAbortController = new AbortController();
-        this.sseLoopPromise = Promise.all([
+        const sseLoops = [
             this.runSseLoop("event"),
             this.runSseLoop("global-event"),
-            this.runSseLoop("global-sync"),
-        ]).then(() => undefined);
+        ];
+        this.sseLoopPromise = Promise.all(sseLoops).then(() => undefined);
     }
     async runSseLoop(streamName) {
         while (!this.shuttingDown) {
@@ -602,9 +693,6 @@ export class OpenCodeServerAdapter {
     }
     subscribeToSseStream(streamName) {
         const signal = this.sseAbortController?.signal;
-        if (streamName === "global-sync") {
-            return this.client.global.syncEvent.subscribe({ signal });
-        }
         if (streamName === "global-event") {
             return this.client.global.event({ signal });
         }
@@ -618,10 +706,16 @@ export class OpenCodeServerAdapter {
             return null;
         }
         if (typeof rawEvent.type === "string") {
+            if (rawEvent.type === "sync") {
+                return this.normalizeGlobalSyncPayload(rawEvent, rawEvent);
+            }
             return rawEvent;
         }
         const payload = rawEvent.payload;
         if (isRecord(payload) && typeof payload.type === "string") {
+            if (payload.type === "sync") {
+                return this.normalizeGlobalSyncPayload(payload, rawEvent);
+            }
             const normalized = { ...payload };
             if (typeof rawEvent.directory === "string") {
                 normalized.directory = rawEvent.directory;
@@ -630,6 +724,17 @@ export class OpenCodeServerAdapter {
         }
         return null;
     }
+    normalizeGlobalSyncPayload(payload, envelope) {
+        const syncEvent = isRecord(payload.syncEvent) ? payload.syncEvent : undefined;
+        if (!syncEvent || typeof syncEvent.type !== "string") {
+            return null;
+        }
+        const normalized = { ...syncEvent };
+        if (typeof envelope.directory === "string") {
+            normalized.directory = envelope.directory;
+        }
+        return normalized;
+    }
     shouldHandleSseEvent(event, streamName) {
         if (streamName === "event") {
             return true;
@@ -642,7 +747,10 @@ export class OpenCodeServerAdapter {
                 type !== "command.executed" &&
                 type !== "session.created" &&
                 type !== "session.updated" &&
-                type !== "session.deleted") {
+                type !== "session.deleted" &&
+                type !== "question.asked" &&
+                type !== "question.replied" &&
+                type !== "question.rejected") {
                 return false;
             }
             if (this.isImplicitLocalCompanionUiEvent(type)) {
@@ -651,13 +759,6 @@ export class OpenCodeServerAdapter {
             return (this.matchesCurrentDirectoryEvent(event) ||
                 this.shouldAcceptUnscopedLocalSessionCreatedEvent(event));
         }
-        if (type === "session.created" ||
-            type === "session.updated" ||
-            type === "session.deleted") {
-            return (this.matchesCurrentDirectoryEvent(event) ||
-                (type === "session.created" &&
-                    this.shouldAcceptUnscopedLocalSessionCreatedEvent(event)));
-        }
         return false;
     }
     isImplicitLocalCompanionUiEvent(type) {
@@ -696,6 +797,15 @@ export class OpenCodeServerAdapter {
                 this.handlePermissionRequest(payload);
                 return;
             }
+            case "question.asked": {
+                this.handleQuestionAsked(payload);
+                return;
+            }
+            case "question.replied":
+            case "question.rejected": {
+                this.handleQuestionSettled(payload);
+                return;
+            }
             case "session.created": {
                 this.handleSessionCreated(payload);
                 return;
@@ -757,26 +867,42 @@ export class OpenCodeServerAdapter {
         if (!this.syncTrackedSessionFromEvent(sessionId, { allowLocalTurnFollow: false })) {
             return;
         }
-        if (this.state.status !== "busy" && this.state.status !== "awaiting_approval") {
+        if (this.state.status !== "busy" &&
+            this.state.status !== "awaiting_approval" &&
+            this.state.status !== "awaiting_input") {
             return;
         }
         // Wait a short settle time before emitting task_complete,
         // in case more events follow the idle signal.
         setTimeout(() => {
-            if (this.state.status !== "busy" && this.state.status !== "awaiting_approval") {
+            if (this.state.status !== "busy" &&
+                this.state.status !== "awaiting_approval" &&
+                this.state.status !== "awaiting_input") {
                 return;
             }
             this.clearWechatWorkingNotice(true);
             this.pendingLocalPrompt = "";
             this.clearPendingPermissionState();
+            this.clearPendingQuestionState();
             this.state.activeTurnOrigin = undefined;
             this.hasAcceptedInput = false;
             const completedPreview = this.currentPreview;
             const turnStartedAtMs = this.lastBusyAtMs;
+            const completingTurnToken = this.currentTurnToken;
             void this.outputBatcher.flushNow()
                 .catch(() => undefined)
                 .then(async () => {
+                // A newer turn (local or wechat) may have started while we awaited
+                // the flush. If so, this completion is stale: dropping it avoids
+                // flipping the active turn back to idle, emitting the old final_reply,
+                // and clearing the new turn's buffered output.
+                if (this.currentTurnToken !== completingTurnToken) {
+                    return;
+                }
                 const finalReplyText = await this.resolveFinalReplyText(sessionId, turnStartedAtMs);
+                if (this.currentTurnToken !== completingTurnToken) {
+                    return;
+                }
                 this.setStatus("idle");
                 if (finalReplyText) {
                     this.emit({
@@ -858,6 +984,114 @@ export class OpenCodeServerAdapter {
         this.state.pendingApproval = null;
         this.state.pendingApprovalOrigin = undefined;
     }
+    handleQuestionAsked(properties) {
+        if (!isRecord(properties) || !this.client) {
+            return;
+        }
+        const sessionId = this.extractSessionId(properties);
+        if (!sessionId || !this.syncTrackedSessionFromEvent(sessionId)) {
+            return;
+        }
+        const requestId = typeof properties.id === "string" ? properties.id : null;
+        if (!requestId || !Array.isArray(properties.questions)) {
+            return;
+        }
+        const questions = properties.questions.flatMap((candidate, index) => {
+            if (!isRecord(candidate)) {
+                return [];
+            }
+            const header = typeof candidate.header === "string" ? candidate.header.trim() : "";
+            const question = typeof candidate.question === "string" ? candidate.question.trim() : "";
+            if (!header || !question) {
+                return [];
+            }
+            const options = Array.isArray(candidate.options)
+                ? candidate.options.flatMap((option) => {
+                    if (!isRecord(option) || typeof option.label !== "string") {
+                        return [];
+                    }
+                    return [{
+                            label: option.label,
+                            description: typeof option.description === "string" ? option.description : "",
+                        }];
+                })
+                : [];
+            return [{
+                    id: `question_${index + 1}`,
+                    header,
+                    question,
+                    isOther: candidate.custom === true,
+                    isSecret: false,
+                    multiple: candidate.multiple === true,
+                    customAnswerMode: "value",
+                    options,
+                }];
+        });
+        if (questions.length !== properties.questions.length || questions.length === 0) {
+            return;
+        }
+        const request = {
+            summary: `OpenCode requested answers to ${questions.length} question${questions.length === 1 ? "" : "s"}.`,
+            questions,
+        };
+        this.pendingQuestion = {
+            sessionId,
+            requestId,
+            request,
+        };
+        this.state.pendingUserInput = request;
+        this.state.pendingUserInputOrigin = this.state.activeTurnOrigin;
+        this.clearWechatWorkingNotice();
+        this.setStatus("awaiting_input", "OpenCode is waiting for user input.");
+        this.emit({
+            type: "user_input_required",
+            request,
+            timestamp: nowIso(),
+        });
+    }
+    handleQuestionSettled(properties) {
+        if (!isRecord(properties) || !this.pendingQuestion) {
+            return;
+        }
+        const sessionId = this.extractSessionId(properties);
+        const requestId = typeof properties.requestID === "string" ? properties.requestID : null;
+        if (sessionId !== this.pendingQuestion.sessionId ||
+            requestId !== this.pendingQuestion.requestId) {
+            return;
+        }
+        this.clearPendingQuestionState();
+        if (this.state.status === "awaiting_input") {
+            this.setStatus("busy", "OpenCode user input resolved.");
+        }
+    }
+    clearPendingQuestionState() {
+        this.pendingQuestion = null;
+        this.state.pendingUserInput = null;
+        this.state.pendingUserInputOrigin = undefined;
+    }
+    async rejectPendingQuestion(pending) {
+        const client = this.client;
+        if (!client) {
+            return;
+        }
+        try {
+            const result = await client.question.reject({
+                requestID: pending.requestId,
+                directory: this.options.cwd,
+                workspace: this.activeWorkspaceId ?? undefined,
+            });
+            if (result.error !== undefined) {
+                throw new Error(`SDK error: ${describeUnknownError(result.error)}`);
+            }
+        }
+        catch (err) {
+            this.emit({
+                type: "stderr",
+                text: `Failed to reject OpenCode user input: ${describeUnknownError(err)}`,
+                timestamp: nowIso(),
+            });
+        }
+    }
     getWechatOutboundAttachmentPermissionDenyMessage(properties, pendingPermission) {
         const metadata = isRecord(properties.metadata) ? properties.metadata : {};
         const command = this.extractPermissionCommand(properties, metadata);
@@ -889,12 +1123,11 @@ export class OpenCodeServerAdapter {
         }
         void (async () => {
             try {
-                const result = await client.permission.respond({
-                    sessionID: pendingPermission.sessionId,
-                    permissionID: pendingPermission.permissionId,
+                const result = await client.permission.reply({
+                    requestID: pendingPermission.permissionId,
                     directory: this.options.cwd,
                     workspace: this.activeWorkspaceId ?? undefined,
-                    response: "reject",
+                    reply: "reject",
                 });
                 if (result.error !== undefined) {
                     throw new Error(`SDK error: ${describeUnknownError(result.error)}`);
@@ -1618,6 +1851,7 @@ export class OpenCodeServerAdapter {
         return session;
     }
     beginTrackedTurn(text, origin, options = {}) {
+        this.currentTurnToken += 1;
         this.hasAcceptedInput = true;
         this.currentPreview = truncatePreview(text);
         this.state.lastInputAt = nowIso();
@@ -1644,8 +1878,10 @@ export class OpenCodeServerAdapter {
     hasTrackedTurnState() {
         return (this.state.status === "busy" ||
             this.state.status === "awaiting_approval" ||
+            this.state.status === "awaiting_input" ||
             this.hasAcceptedInput ||
             this.pendingPermission !== null ||
+            this.pendingQuestion !== null ||
             this.state.activeTurnOrigin !== undefined ||
             this.currentPreview !== "(idle)");
     }
@@ -1654,6 +1890,7 @@ export class OpenCodeServerAdapter {
         this.pendingLocalPrompt = "";
         this.localPromptNoticeSent = false;
         this.clearPendingPermissionState();
+        this.clearPendingQuestionState();
         this.state.activeTurnOrigin = undefined;
         this.hasAcceptedInput = false;
         this.currentPreview = "(idle)";
@@ -2224,6 +2461,15 @@ export class OpenCodeServerAdapter {
                 const sessionId = this.extractSessionId(payload);
                 return sessionId ? `${type}:${sessionId}` : null;
             }
+            case "question.asked": {
+                const requestId = typeof payload.id === "string" ? payload.id : undefined;
+                return requestId ? `${type}:${requestId}` : null;
+            }
+            case "question.replied":
+            case "question.rejected": {
+                const requestId = typeof payload.requestID === "string" ? payload.requestID : undefined;
+                return requestId ? `${type}:${requestId}` : null;
+            }
             default:
                 return null;
         }