@co0ontty/wand 3.1.1 → 4.0.0

package/dist/structured-claude-adapter.js

@@ -0,0 +1,117 @@
+import { readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { isRunningAsRoot } from "./env-utils.js";
+import { buildLanguageDirective, buildManagedAutonomyDirective } from "./language-prompt.js";
+import { thinkingEffortToClaudeCliEffort, thinkingEffortToSdkBudget } from "./structured-provider-common.js";
+const ROOT_FALLBACK_ALLOWED_TOOLS = [
+    "Bash", "Edit", "Write", "Read", "Glob", "Grep", "NotebookEdit", "WebFetch", "WebSearch",
+];
+const mcpServerCache = new Map();
+function readJsonSafe(filePath) {
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function mtimeOf(filePath) {
+    try {
+        return statSync(filePath).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+function extractMcpServerKeys(node) {
+    if (!node || typeof node !== "object")
+        return [];
+    const mcpServers = node.mcpServers;
+    return mcpServers && typeof mcpServers === "object"
+        ? Object.keys(mcpServers)
+        : [];
+}
+function collectMcpServerNames(cwd) {
+    const userConfigPath = path.join(homedir(), ".claude.json");
+    const projectMcpPath = path.join(cwd, ".mcp.json");
+    const fingerprint = `${mtimeOf(userConfigPath)}:${mtimeOf(projectMcpPath)}`;
+    const cached = mcpServerCache.get(cwd);
+    if (cached?.mtimeFingerprint === fingerprint)
+        return cached.names;
+    const names = new Set();
+    const userConfig = readJsonSafe(userConfigPath);
+    if (userConfig) {
+        for (const name of extractMcpServerKeys(userConfig))
+            names.add(name);
+        const projects = userConfig.projects;
+        if (projects && typeof projects === "object") {
+            for (const name of extractMcpServerKeys(projects[cwd]))
+                names.add(name);
+        }
+    }
+    for (const name of extractMcpServerKeys(readJsonSafe(projectMcpPath)))
+        names.add(name);
+    const result = Array.from(names);
+    mcpServerCache.set(cwd, { mtimeFingerprint: fingerprint, names: result });
+    return result;
+}
+export function derivePermissionPolicy(mode, autoApprove, cwd) {
+    const shouldBypass = autoApprove || mode === "full-access" || mode === "managed";
+    const shouldAcceptEdits = mode === "auto-edit";
+    const mcpAllow = shouldBypass ? [] : collectMcpServerNames(cwd).map((name) => `mcp__${name}`);
+    const withMcp = (base) => {
+        if (!mcpAllow.length)
+            return base;
+        return base ? [...base, ...mcpAllow] : [...mcpAllow];
+    };
+    if (!isRunningAsRoot()) {
+        if (shouldBypass)
+            return { permissionMode: "bypassPermissions", allowedTools: undefined };
+        if (shouldAcceptEdits)
+            return { permissionMode: "acceptEdits", allowedTools: withMcp(undefined) };
+        return { permissionMode: "default", allowedTools: withMcp(undefined) };
+    }
+    if (shouldBypass || shouldAcceptEdits) {
+        return { permissionMode: "acceptEdits", allowedTools: withMcp(ROOT_FALLBACK_ALLOWED_TOOLS) };
+    }
+    return { permissionMode: "default", allowedTools: withMcp(undefined) };
+}
+export function buildAppendSystemPromptParts(language, mode) {
+    const trimmedLanguage = language?.trim();
+    const parts = [];
+    if (mode === "managed")
+        parts.push(buildManagedAutonomyDirective(trimmedLanguage === "中文"));
+    if (trimmedLanguage) {
+        const directive = buildLanguageDirective(trimmedLanguage);
+        if (directive)
+            parts.push(directive);
+    }
+    return parts;
+}
+export function buildClaudeCliArgs(session, options) {
+    const args = ["-p", "--verbose", "--output-format", "stream-json"];
+    if (options.permissionPolicy.permissionMode !== "default") {
+        args.push("--permission-mode", options.permissionPolicy.permissionMode);
+    }
+    if (options.permissionPolicy.allowedTools)
+        args.push("--allowedTools", ...options.permissionPolicy.allowedTools);
+    for (const part of options.systemPromptParts ?? [])
+        args.push("--append-system-prompt", part);
+    const modelChoice = session.selectedModel?.trim();
+    if (modelChoice && modelChoice !== "default")
+        args.push("--model", modelChoice);
+    const effort = thinkingEffortToClaudeCliEffort(session.thinkingEffort);
+    if (effort)
+        args.push("--effort", effort);
+    if (session.mode === "managed")
+        args.push("--disallowedTools", "AskUserQuestion");
+    if (session.claudeSessionId)
+        args.push("--resume", session.claudeSessionId);
+    return args;
+}
+export function buildClaudeSdkThinking(effort) {
+    const budgetTokens = thinkingEffortToSdkBudget(effort);
+    return budgetTokens > 0 ? { type: "enabled", budgetTokens } : { type: "disabled" };
+}

package/dist/structured-codex-adapter.d.ts

@@ -0,0 +1,3 @@
+import type { SessionSnapshot } from "./types.js";
+/** Build the stable CLI contract for a structured Codex turn. */
+export declare function buildCodexArgs(session: SessionSnapshot): string[];

package/dist/structured-codex-adapter.js

@@ -0,0 +1,29 @@
+import { thinkingEffortToCodexReasoningEffort } from "./structured-provider-common.js";
+/** Build the stable CLI contract for a structured Codex turn. */
+export function buildCodexArgs(session) {
+    const args = ["exec", "--json", "--color", "never"];
+    const shouldBypass = session.autoApprovePermissions === true
+        || session.mode === "full-access"
+        || session.mode === "managed";
+    if (shouldBypass) {
+        args.push("--dangerously-bypass-approvals-and-sandbox");
+    }
+    else if (session.mode === "auto-edit" || session.mode === "agent" || session.mode === "agent-max") {
+        args.push("--sandbox", "workspace-write");
+    }
+    else {
+        args.push("--sandbox", "read-only");
+    }
+    args.push("--skip-git-repo-check");
+    const modelChoice = session.selectedModel?.trim();
+    if (modelChoice && modelChoice !== "default")
+        args.push("--model", modelChoice);
+    const reasoningEffort = thinkingEffortToCodexReasoningEffort(session.thinkingEffort);
+    if (reasoningEffort)
+        args.push("-c", `model_reasoning_effort=${reasoningEffort}`);
+    if (session.claudeSessionId)
+        args.push("resume", session.claudeSessionId, "-");
+    else
+        args.push("-");
+    return args;
+}

package/dist/structured-opencode-adapter.d.ts

@@ -0,0 +1,11 @@
+import type { ContentBlock, ConversationTurn, SessionSnapshot } from "./types.js";
+export interface OpenCodeTurnState {
+    blocks: ContentBlock[];
+    result: string;
+    sessionId: string | null;
+    usage?: ConversationTurn["usage"];
+}
+export declare function buildOpenCodeArgs(session: SessionSnapshot): string[];
+export declare function openCodeToolName(name: string): string;
+/** Apply one OpenCode NDJSON event to the current transport-neutral turn state. */
+export declare function applyOpenCodeEvent(turnState: OpenCodeTurnState, event: Record<string, unknown>, createId?: () => string): string | null;

package/dist/structured-opencode-adapter.js

@@ -0,0 +1,115 @@
+import { randomUUID } from "node:crypto";
+import { thinkingEffortToOpenCodeVariant } from "./structured-provider-common.js";
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function extractStructuredText(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.map(extractStructuredText).filter(Boolean).join("\n");
+    const record = asRecord(value);
+    if (!record)
+        return "";
+    for (const key of ["text", "output_text", "message", "content", "summary"]) {
+        const text = extractStructuredText(record[key]);
+        if (text)
+            return text;
+    }
+    return "";
+}
+export function 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;
+}
+export function 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}`;
+}
+/** Apply one OpenCode NDJSON event to the current transport-neutral turn state. */
+export function applyOpenCodeEvent(turnState, event, createId = randomUUID) {
+    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 extractStructuredText(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
+                : createId();
+        const input = asRecord(state.input) ?? {};
+        turnState.blocks.push({
+            type: "tool_use",
+            id: toolId,
+            name: 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;
+}

package/dist/structured-provider-common.d.ts

@@ -0,0 +1,11 @@
+import type { SessionProvider, SessionRunner, SessionSnapshot, StructuredSessionState, WandConfig } from "./types.js";
+export declare function isStructuredRunnerForProvider(provider: SessionProvider, runner: unknown): runner is SessionRunner;
+export declare function defaultStructuredRunner(provider: SessionProvider, configuredClaudeRunner?: WandConfig["structuredRunner"]): SessionRunner;
+export declare function resolveStructuredRunner(provider: SessionProvider, requestedRunner: unknown, configuredClaudeRunner?: WandConfig["structuredRunner"]): SessionRunner;
+export declare function defaultStructuredState(provider: SessionProvider, runner?: SessionRunner): StructuredSessionState;
+export declare function normalizeThinkingEffort(value: unknown): SessionSnapshot["thinkingEffort"];
+export declare function thinkingEffortToSdkBudget(effort: SessionSnapshot["thinkingEffort"]): number;
+export declare function thinkingEffortToClaudeCliEffort(effort: SessionSnapshot["thinkingEffort"]): string | null;
+export declare function thinkingEffortToClaudeSlashEffort(effort: SessionSnapshot["thinkingEffort"]): string;
+export declare function thinkingEffortToCodexReasoningEffort(effort: SessionSnapshot["thinkingEffort"]): string | null;
+export declare function thinkingEffortToOpenCodeVariant(effort: SessionSnapshot["thinkingEffort"]): string | null;

package/dist/structured-provider-common.js

@@ -0,0 +1,77 @@
+export function isStructuredRunnerForProvider(provider, runner) {
+    if (provider === "claude")
+        return runner === "claude-sdk" || runner === "claude-cli-print";
+    if (provider === "codex")
+        return runner === "codex-cli-exec";
+    return runner === "opencode-cli-run";
+}
+export function defaultStructuredRunner(provider, configuredClaudeRunner = "cli") {
+    if (provider === "codex")
+        return "codex-cli-exec";
+    if (provider === "opencode")
+        return "opencode-cli-run";
+    return configuredClaudeRunner === "sdk" ? "claude-sdk" : "claude-cli-print";
+}
+export function resolveStructuredRunner(provider, requestedRunner, configuredClaudeRunner = "cli") {
+    const runner = requestedRunner ?? defaultStructuredRunner(provider, configuredClaudeRunner);
+    if (!isStructuredRunnerForProvider(provider, runner)) {
+        throw new Error(`runner ${String(runner)} 不支持 provider ${provider}。`);
+    }
+    return runner;
+}
+export function defaultStructuredState(provider, runner = defaultStructuredRunner(provider)) {
+    return { provider, runner, lastError: null, inFlight: false, activeRequestId: null };
+}
+export function normalizeThinkingEffort(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "off" || normalized === "standard" || normalized === "deep" || normalized === "max")
+        return normalized;
+    if (/^codex:[a-z0-9][a-z0-9_-]{0,31}$/.test(normalized))
+        return normalized;
+    return null;
+}
+export function thinkingEffortToSdkBudget(effort) {
+    if (effort === "standard")
+        return 4096;
+    if (effort === "deep")
+        return 16000;
+    if (effort === "max")
+        return 31999;
+    return 0;
+}
+export function thinkingEffortToClaudeCliEffort(effort) {
+    if (effort === "standard")
+        return "low";
+    if (effort === "deep")
+        return "medium";
+    if (effort === "max")
+        return "max";
+    return null;
+}
+export function thinkingEffortToClaudeSlashEffort(effort) {
+    return thinkingEffortToClaudeCliEffort(effort) ?? "auto";
+}
+export function thinkingEffortToCodexReasoningEffort(effort) {
+    if (typeof effort === "string" && effort.startsWith("codex:"))
+        return effort.slice("codex:".length) || null;
+    if (effort === "standard")
+        return "low";
+    if (effort === "deep")
+        return "medium";
+    if (effort === "max")
+        return "xhigh";
+    return null;
+}
+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;
+}

package/dist/structured-session-manager.d.ts

@@ -1,6 +1,8 @@
+import { query as sdkQuery } from "@anthropic-ai/claude-agent-sdk";
 import { SessionLogger } from "./session-logger.js";
 import { WandStorage } from "./storage.js";
 import { ContentBlock, ExecutionMode, ProcessEvent, SessionProvider, SessionRunner, SessionSnapshot, SessionSource, WandConfig } from "./types.js";
+export { isStructuredRunnerForProvider, normalizeThinkingEffort, resolveStructuredRunner, thinkingEffortToClaudeCliEffort, thinkingEffortToCodexReasoningEffort, thinkingEffortToOpenCodeVariant, thinkingEffortToSdkBudget, } from "./structured-provider-common.js";
 interface CreateStructuredSessionOptions {
     cwd: string;
     mode: ExecutionMode;
@@ -21,21 +23,6 @@ interface CreateStructuredSessionOptions {
      */
     claudeSessionId?: string;
 }
-/**
- * 把任意外部输入收敛到合法的 thinkingEffort 枚举值。`null` / 非法值都视为
- * "未设置"——上层调用方再根据 provider 决定是否填默认值。
- */
-export declare function normalizeThinkingEffort(value: unknown): SessionSnapshot["thinkingEffort"];
-/** Claude SDK 用：把 thinkingEffort 映射成 `thinking.budget_tokens`。off / 空 → 0（不启用）。 */
-export declare function thinkingEffortToSdkBudget(effort: SessionSnapshot["thinkingEffort"]): number;
-/** Claude CLI 用：把 thinkingEffort 映射到 `--effort` / `/effort` 支持的等级。off → 不覆盖默认值。 */
-export declare function thinkingEffortToClaudeCliEffort(effort: SessionSnapshot["thinkingEffort"]): string | null;
-/** Claude PTY slash-command 用：off 表示恢复模型默认 effort。 */
-export declare function thinkingEffortToClaudeSlashEffort(effort: SessionSnapshot["thinkingEffort"]): string;
-/** Codex CLI 用：把 thinkingEffort 映射到 model_reasoning_effort 配置。off → 不覆盖 Codex 默认。 */
-export declare function thinkingEffortToCodexReasoningEffort(effort: SessionSnapshot["thinkingEffort"]): string | null;
-/** OpenCode exposes provider-specific reasoning presets through `--variant`. */
-export declare function thinkingEffortToOpenCodeVariant(effort: SessionSnapshot["thinkingEffort"]): string | null;
 /**
  * Preserve both Responses content-part arrays and arbitrary structured tool output.
  * Arrays without a `type` discriminator (for example Codex tool_search results)
@@ -73,6 +60,7 @@ export declare class StructuredSessionManager {
     private readonly storage;
     private readonly config;
     private readonly logger;
+    private readonly sdkQueryFactory;
     private readonly sessions;
     private readonly pendingChildren;
     private readonly pendingSdkAbort;
@@ -83,12 +71,6 @@ export declare class StructuredSessionManager {
      */
     private readonly pendingSdkQueries;
     private readonly interruptedWith;
-    /**
-     * 用户主动点了「停止」的会话。异步收尾（claude -p / codex 的 close、SDK 的 abort）
-     * 据此跳过"结构化会话执行失败"路径——主动停止不是失败，按正常 idle 收尾、保留历史内容。
-     * 用 Set.delete 消费：读取的同时清除，下一轮真失败不会被旧标记误抑制。
-     */
-    private readonly userStopped;
     /**
      * Sessions where the current interrupt is a "queue promote" (用户从排队条点了「立即」
      * 把队首插队到 now)。退出处理三个分支默认会把 queuedMessages 清空——因为常规的
@@ -97,8 +79,10 @@ export declare class StructuredSessionManager {
      * 收到后必须 delete 掉，避免下一次普通 interrupt 误带 flag。
      */
     private readonly preserveQueueOnInterrupt;
-    /** Last wall-clock time (ms) we did a full saveSession for a streaming session. */
+    /** Last wall-clock time (ms) a streaming checkpoint reached SQLite. */
     private readonly lastStreamSaveAt;
+    private readonly streamCheckpointTimers;
+    private readonly streamCheckpointDirty;
     /**
      * Idempotency keys we've already accepted, mapped to their wall-clock timestamp.
      * Android WebView 在进程恢复时偶尔会重发上一个未收到响应的 POST（HTTP/2 stream
@@ -110,21 +94,32 @@ export declare class StructuredSessionManager {
     private emitEvent;
     private archiveTimer;
     private readonly topicRequests;
-    constructor(storage: WandStorage, config: WandConfig, logger?: SessionLogger | null);
+    private readonly streamEmitTimers;
+    private disposed;
+    constructor(storage: WandStorage, config: WandConfig, logger?: SessionLogger | null, sdkQueryFactory?: typeof sdkQuery);
     private archiveExpiredSessions;
     setEventEmitter(emitEvent: (event: ProcessEvent) => void): void;
-    /**
-     * In-memory snapshot is updated unconditionally; the SQLite write is rate-
-     * limited to once per STREAM_SAVE_THROTTLE_MS. Caller must still invoke
-     * `storage.saveSession` directly at terminal events (close / failure) so the
-     * final state is durable.
-     */
+    /** Stop every runner and flush terminal state before storage is closed. */
+    dispose(): void;
+    private trackStreamEmitTimer;
+    private clearStreamEmitTimer;
+    /** Mark streaming payload dirty and enforce both leading and trailing checkpoints. */
     private saveStreamingSnapshot;
+    private flushStreamingCheckpoint;
+    private clearStreamingCheckpoint;
+    private cancelStreamingCheckpointTimer;
+    private saveAuthoritativeSession;
+    private checkpointSessionMessages;
     list(): SessionSnapshot[];
     /** Return lightweight snapshots for the session list (no output/messages). */
     listSlim(): SessionSnapshot[];
     get(id: string): SessionSnapshot | null;
     setSessionTopic(id: string, title: string, description: string): SessionSnapshot;
+    /**
+     * Update worktree merge progress on the canonical in-memory snapshot before
+     * persisting it. A null result means this manager does not own the session.
+     */
+    setWorktreeMergeState(id: string, status: SessionSnapshot["worktreeMergeStatus"], info: SessionSnapshot["worktreeMergeInfo"]): SessionSnapshot | null;
     private maybeGenerateSessionTopic;
     createSession(options: CreateStructuredSessionOptions): SessionSnapshot;
     sendMessage(id: string, input: string, opts?: {
@@ -170,19 +165,22 @@ export declare class StructuredSessionManager {
     /** Toggle auto-approve for the session. */
     toggleAutoApprove(sessionId: string): SessionSnapshot;
     /** Resolve a specific escalation by requestId. */
-    resolveEscalation(sessionId: string, requestId: string, resolution?: "approve_once" | "approve_turn" | "deny"): SessionSnapshot;
+    resolveEscalation(sessionId: string, requestId: string, resolution: unknown): SessionSnapshot;
     stop(id: string): SessionSnapshot;
     delete(id: string): void;
     private requireSession;
+    /** True only while this exact turn still owns the session's mutable state. */
+    private isCurrentRequest;
+    private currentSessionForRequest;
+    /** Delete a handle only if it still belongs to the execution doing cleanup. */
+    private releasePendingChild;
+    private releasePendingSdkAbort;
+    private releasePendingSdkQuery;
     private emitStructuredSnapshot;
     private flushNextQueuedMessage;
     private emit;
     private incrementApprovalStats;
-    private buildCodexArgs;
     private runCodexStreaming;
-    private buildOpenCodeArgs;
-    private openCodeToolName;
-    private applyOpenCodeEvent;
     private runOpenCodeStreaming;
     /**
      * Spawn `claude -p --output-format stream-json` and parse NDJSON lines as
@@ -277,4 +275,3 @@ export declare class StructuredSessionManager {
     private extractSdkUsage;
     private extractCodexUsage;
 }
-export {};