@co0ontty/wand 2.12.0 → 2.13.0

package/dist/structured-session-manager.js

@@ -13,7 +13,7 @@ import { buildLanguageDirective, buildManagedAutonomyDirective } from "./languag
 import { generateSessionTopic } from "./session-topic.js";
 import { resolveSessionCwd } from "./session-cwd.js";
 function defaultStructuredRunner(provider) {
-    return provider === "codex" ? "codex-cli-exec" : "claude-cli-print";
+    return provider === "codex" ? "codex-cli-exec" : provider === "opencode" ? "opencode-cli-run" : "claude-cli-print";
 }
 function defaultStructuredState(provider, runner = defaultStructuredRunner(provider)) {
     return {
@@ -75,6 +75,18 @@ export function thinkingEffortToCodexReasoningEffort(effort) {
         default: return null;
     }
 }
+/** OpenCode exposes provider-specific reasoning presets through `--variant`. */
+export function thinkingEffortToOpenCodeVariant(effort) {
+    if (!effort || effort === "off")
+        return null;
+    if (effort === "standard")
+        return "low";
+    if (effort === "deep")
+        return "high";
+    if (effort === "max")
+        return "max";
+    return effort.startsWith("codex:") ? effort.slice("codex:".length) || null : null;
+}
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -914,7 +926,7 @@ export class StructuredSessionManager {
         const id = randomUUID();
         const startedAt = new Date().toISOString();
         const prompt = options.prompt?.trim();
-        const provider = options.provider === "codex" ? "codex" : "claude";
+        const provider = options.provider === "codex" || options.provider === "opencode" ? options.provider : "claude";
         const runner = options.runner ?? defaultStructuredRunner(provider);
         const baseCwd = resolveSessionCwd(options.cwd, this.config.defaultCwd);
         const worktreeSetup = options.worktreeEnabled
@@ -931,9 +943,11 @@ export class StructuredSessionManager {
             runner,
             command: provider === "codex"
                 ? "codex exec --json"
-                : runner === "claude-sdk"
-                    ? "claude-agent-sdk (stream-json)"
-                    : "claude -p --output-format stream-json",
+                : provider === "opencode"
+                    ? "opencode run --format json"
+                    : runner === "claude-sdk"
+                        ? "claude-agent-sdk (stream-json)"
+                        : "claude -p --output-format stream-json",
             cwd: worktreeSetup?.cwd ?? baseCwd,
             mode: options.mode,
             worktreeEnabled: Boolean(worktreeSetup),
@@ -1122,6 +1136,9 @@ export class StructuredSessionManager {
             if ((updated.provider ?? "claude") === "codex") {
                 await this.runCodexStreaming(id, updated, prompt);
             }
+            else if ((updated.provider ?? "claude") === "opencode") {
+                await this.runOpenCodeStreaming(id, updated, prompt);
+            }
             else if (this.config.structuredRunner === "sdk") {
                 await this.runClaudeSdkStreaming(id, updated, prompt);
             }
@@ -1850,6 +1867,280 @@ export class StructuredSessionManager {
             });
         });
     }
+    buildOpenCodeArgs(session) {
+        const args = ["run", "--format", "json", "--thinking"];
+        const modelChoice = session.selectedModel?.trim();
+        if (modelChoice && modelChoice !== "default") {
+            args.push("--model", modelChoice);
+        }
+        const variant = thinkingEffortToOpenCodeVariant(session.thinkingEffort);
+        if (variant)
+            args.push("--variant", variant);
+        if (session.autoApprovePermissions === true || session.mode === "full-access" || session.mode === "managed" || session.mode === "auto-edit") {
+            args.push("--dangerously-skip-permissions");
+        }
+        if (session.claudeSessionId) {
+            args.push("--session", session.claudeSessionId);
+        }
+        return args;
+    }
+    openCodeToolName(name) {
+        const mapped = {
+            bash: "Bash",
+            shell: "Bash",
+            read: "Read",
+            edit: "Edit",
+            write: "Write",
+            glob: "Glob",
+            grep: "Grep",
+            webfetch: "WebFetch",
+            websearch: "WebSearch",
+            todowrite: "TodoWrite",
+            task: "Task",
+            skill: "Skill",
+        };
+        return mapped[name.toLowerCase()] ?? `OpenCode/${name}`;
+    }
+    applyOpenCodeEvent(turnState, event) {
+        if (typeof event.sessionID === "string" && event.sessionID)
+            turnState.sessionId = event.sessionID;
+        const type = typeof event.type === "string" ? event.type : "";
+        const part = asRecord(event.part);
+        if (!part) {
+            if (type === "error")
+                return this.extractCodexText(event.error) || "OpenCode run failed";
+            return null;
+        }
+        if (type === "text" && typeof part.text === "string" && part.text.trim()) {
+            turnState.blocks.push({ type: "text", text: part.text });
+            turnState.result += (turnState.result ? "\n" : "") + part.text;
+            return null;
+        }
+        if (type === "reasoning" && typeof part.text === "string" && part.text.trim()) {
+            turnState.blocks.push({ type: "thinking", thinking: part.text });
+            return null;
+        }
+        if (type === "tool_use") {
+            const state = asRecord(part.state) ?? {};
+            const tool = typeof part.tool === "string" && part.tool ? part.tool : "tool";
+            const toolId = typeof part.callID === "string" && part.callID
+                ? part.callID
+                : typeof part.id === "string" && part.id
+                    ? part.id
+                    : randomUUID();
+            const input = asRecord(state.input) ?? {};
+            turnState.blocks.push({
+                type: "tool_use",
+                id: toolId,
+                name: this.openCodeToolName(tool),
+                description: typeof state.title === "string" ? state.title : undefined,
+                input,
+            });
+            const failed = state.status === "error";
+            const content = failed
+                ? (typeof state.error === "string" ? state.error : "OpenCode tool failed")
+                : (typeof state.output === "string" ? state.output : "");
+            turnState.blocks.push({ type: "tool_result", tool_use_id: toolId, content, is_error: failed });
+            return null;
+        }
+        if (type === "step_finish") {
+            const tokens = asRecord(part.tokens);
+            const cache = asRecord(tokens?.cache);
+            const previous = turnState.usage ?? {};
+            turnState.usage = {
+                inputTokens: (previous.inputTokens ?? 0) + (typeof tokens?.input === "number" ? tokens.input : 0),
+                outputTokens: (previous.outputTokens ?? 0) + (typeof tokens?.output === "number" ? tokens.output : 0),
+                reasoningOutputTokens: (previous.reasoningOutputTokens ?? 0) + (typeof tokens?.reasoning === "number" ? tokens.reasoning : 0),
+                cacheReadInputTokens: (previous.cacheReadInputTokens ?? 0) + (typeof cache?.read === "number" ? cache.read : 0),
+                cacheCreationInputTokens: (previous.cacheCreationInputTokens ?? 0) + (typeof cache?.write === "number" ? cache.write : 0),
+                totalCostUsd: (previous.totalCostUsd ?? 0) + (typeof part.cost === "number" ? part.cost : 0),
+            };
+        }
+        return null;
+    }
+    runOpenCodeStreaming(sessionId, session, prompt) {
+        this.userStopped.delete(sessionId);
+        return new Promise((resolve, reject) => {
+            const args = this.buildOpenCodeArgs(session);
+            const spawnedAt = new Date().toISOString();
+            const child = spawn("opencode", args, {
+                cwd: session.cwd,
+                env: buildChildEnv(this.config.inheritEnv !== false),
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            this.logger?.appendStructuredSpawn(sessionId, {
+                kind: "opencode-run",
+                provider: "opencode",
+                pid: child.pid ?? null,
+                cwd: session.cwd,
+                args,
+                prompt: prompt.slice(0, 2048),
+                promptLength: prompt.length,
+                sessionId: session.claudeSessionId,
+                spawnedAt,
+            });
+            this.pendingChildren.set(sessionId, child);
+            child.stdin?.end(prompt);
+            const turnState = {
+                blocks: [],
+                result: "",
+                sessionId: session.claudeSessionId,
+                model: session.selectedModel ?? session.structuredState?.model,
+                usage: undefined,
+                codexBlockIndex: new Map(),
+                cwd: session.cwd,
+            };
+            let lineBuf = "";
+            let stderr = "";
+            let primaryError = null;
+            let emitTimer = null;
+            const syncSnapshot = () => {
+                const current = this.sessions.get(sessionId);
+                if (!current)
+                    return;
+                const turn = {
+                    role: "assistant",
+                    content: this.compactContentBlocks([...turnState.blocks], turnState.result),
+                    usage: turnState.usage,
+                };
+                const messages = [...(current.messages ?? [])];
+                if (messages[messages.length - 1]?.role === "assistant")
+                    messages[messages.length - 1] = turn;
+                else
+                    messages.push(turn);
+                const patched = {
+                    ...current,
+                    claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
+                    messages,
+                    output: turnState.result || current.output,
+                };
+                this.sessions.set(sessionId, patched);
+                this.saveStreamingSnapshot(patched);
+            };
+            const flushEmit = () => {
+                if (emitTimer)
+                    clearTimeout(emitTimer);
+                emitTimer = null;
+                const current = this.sessions.get(sessionId);
+                if (current)
+                    this.emit({ type: "output", sessionId, data: buildIncrementalStructuredPayload(current, this.config.cardDefaults ?? {}) });
+            };
+            const scheduleEmit = () => {
+                if (!emitTimer)
+                    emitTimer = setTimeout(flushEmit, STREAM_EMIT_DEBOUNCE_MS);
+            };
+            const processLine = (line) => {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    return;
+                let event;
+                try {
+                    event = JSON.parse(trimmed);
+                }
+                catch {
+                    return;
+                }
+                this.logger?.appendStreamEvent(sessionId, event);
+                const error = this.applyOpenCodeEvent(turnState, event);
+                if (error)
+                    primaryError = error;
+                syncSnapshot();
+                scheduleEmit();
+            };
+            child.stdout?.on("data", (chunk) => {
+                const text = chunk.toString();
+                this.logger?.appendStructuredStdout(sessionId, text);
+                lineBuf += text;
+                const lines = lineBuf.split("\n");
+                lineBuf = lines.pop() ?? "";
+                for (const line of lines)
+                    processLine(line);
+            });
+            child.stderr?.on("data", (chunk) => {
+                const text = chunk.toString();
+                this.logger?.appendStructuredStderr(sessionId, text);
+                stderr += text;
+            });
+            child.on("error", (error) => {
+                this.pendingChildren.delete(sessionId);
+                this.lastStreamSaveAt.delete(sessionId);
+                if (emitTimer)
+                    clearTimeout(emitTimer);
+                const nodeError = error;
+                const hint = nodeError.code === "ENOENT"
+                    ? "（PATH 中找不到 opencode；请安装 opencode-ai，或重跑 `wand service:install` 刷新服务 PATH）"
+                    : "";
+                reject(new Error(`opencode run 启动失败：${error.message}${hint}`));
+            });
+            child.on("close", (code, signal) => {
+                this.pendingChildren.delete(sessionId);
+                this.lastStreamSaveAt.delete(sessionId);
+                if (lineBuf.trim())
+                    processLine(lineBuf);
+                flushEmit();
+                const current = this.sessions.get(sessionId);
+                if (!current) {
+                    reject(new Error("Session removed during execution."));
+                    return;
+                }
+                const interruptedByUser = this.interruptedWith.has(sessionId);
+                const interruptPrompt = this.interruptedWith.get(sessionId);
+                const userStopped = this.userStopped.delete(sessionId);
+                if ((primaryError || (code !== 0 && code !== null) || signal) && !interruptedByUser && !userStopped) {
+                    const legacyHint = /unknown command|unknown flag|No help topic for 'run'/i.test(stderr)
+                        ? "\n检测到旧版 OpenCode CLI；请卸载 0.0.x 旧包并安装 `opencode-ai@latest`。"
+                        : "";
+                    const errorText = this.formatStructuredExitError("opencode run", code, signal, { stderr, primary: primaryError }) + legacyHint;
+                    const failed = this.finishStructuredFailure(current, typeof code === "number" ? code : 1, errorText, turnState);
+                    this.sessions.set(sessionId, failed);
+                    this.storage.saveSession(failed);
+                    this.emitStructuredSnapshot(failed);
+                    this.emitStructuredSnapshot(failed, "ended");
+                    reject(new Error(errorText));
+                    return;
+                }
+                const messages = this.buildCompletedAssistantMessages(current, turnState);
+                const keepRunning = !!interruptPrompt;
+                const finished = {
+                    ...current,
+                    status: keepRunning ? "running" : "idle",
+                    exitCode: keepRunning ? null : 0,
+                    endedAt: keepRunning ? null : new Date().toISOString(),
+                    output: turnState.result,
+                    claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
+                    messages,
+                    queuedMessages: this.resolveQueuedMessagesAfterInterrupt(sessionId, current, interruptPrompt),
+                    pendingEscalation: null,
+                    permissionBlocked: false,
+                    structuredState: {
+                        ...current.structuredState,
+                        model: turnState.model ?? current.structuredState?.model,
+                        inFlight: false,
+                        activeRequestId: null,
+                        lastError: null,
+                    },
+                };
+                this.sessions.set(sessionId, finished);
+                this.storage.saveSession(finished);
+                this.emitStructuredSnapshot(finished);
+                if (!keepRunning)
+                    this.emitStructuredSnapshot(finished, "ended");
+                if (interruptPrompt) {
+                    this.interruptedWith.delete(sessionId);
+                    this.preserveQueueOnInterrupt.delete(sessionId);
+                    resolve();
+                    setImmediate(() => {
+                        this.sendMessage(sessionId, interruptPrompt).catch((error) => {
+                            console.error("[WAND] opencode interrupt-and-send failed:", error);
+                        });
+                    });
+                    return;
+                }
+                resolve();
+                setImmediate(() => { void this.flushNextQueuedMessage(sessionId); });
+            });
+        });
+    }
     // ---------------------------------------------------------------------------
     // Streaming claude -p execution
     // ---------------------------------------------------------------------------

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 export type SessionKind = "pty" | "structured";
-export type SessionProvider = "claude" | "codex";
-export type SessionRunner = "claude-cli" | "claude-cli-print" | "claude-sdk" | "codex-cli-exec" | "pty";
+export type SessionProvider = "claude" | "codex" | "opencode";
+export type SessionRunner = "claude-cli" | "claude-cli-print" | "claude-sdk" | "codex-cli-exec" | "opencode-cli-run" | "pty";
 export type SessionSource = "interactive" | "automation" | "startup";
 export type ExecutionMode = "assist" | "agent" | "agent-max" | "default" | "auto-edit" | "full-access" | "native" | "managed";
 export type AutonomyPolicy = "assist" | "agent" | "agent-max";
@@ -109,6 +109,8 @@ export interface WandConfig {
     defaultModel?: string;
     /** 新建 Codex 会话时默认使用的模型。留空则不传 --model，由 codex 自行决定。 */
     defaultCodexModel?: string;
+    /** 新建 OpenCode 会话时默认使用的 provider/model。留空则由 opencode 自行决定。 */
+    defaultOpenCodeModel?: string;
     /** 快捷提交生成 commit message / tag 时使用的 CLI。 */
     commitCli?: SessionProvider;
     /** 快捷提交专用模型。留空则跟随所选 CLI 的默认模型。 */