wave-code 1.0.6 → 1.0.8

package/dist/contexts/useChat.js

@@ -4,7 +4,6 @@ import { useInput, useStdout } from "ink";
 import { useAppConfig } from "./useAppConfig.js";
 import { Agent, OPERATION_CANCELLED_BY_USER, extractLatestTotalTokens, } from "wave-agent-sdk";
 import { logger } from "../utils/logger.js";
-import { throttle } from "../utils/throttle.js";
 import { displayUsageSummary } from "../utils/usageSummary.js";
 import { expandLongTextPlaceholders } from "../managers/inputHandlers.js";
 const ChatContext = createContext(null);
@@ -75,6 +74,86 @@ function createStreamingWindowThrottle(fn, wait) {
     };
     return throttled;
 }
+/**
+ * Per-tool window-concat throttle for pure-delta tool parameter streaming:
+ * `parametersChunk` deltas are accumulated independently per tool block id
+ * within the cooldown window, so interleaved multi-tool streams lose no delta
+ * (a plain throttle's single last-args slot would drop every earlier tool's
+ * deltas, leaving the first tool without streaming parameters). `start` /
+ * `running` apply immediately (one-shot snapshots); `end` flushes pending
+ * streaming deltas first, then applies the authoritative parameters/result.
+ */
+export function createToolStreamingThrottle(fn, wait) {
+    let timer = null;
+    let pending = null;
+    const fire = () => {
+        if (pending && pending.chunks.size > 0) {
+            const { messageId, chunks } = pending;
+            pending = null;
+            for (const [id, chunk] of chunks) {
+                fn({ messageId, id, parametersChunk: chunk, stage: "streaming" });
+            }
+        }
+    };
+    const throttled = (params) => {
+        if (params.stage === "end") {
+            // Flush any deltas still pending inside the cooldown window first
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            fire();
+            fn(params);
+            return;
+        }
+        if (params.stage === "streaming") {
+            if (!pending) {
+                pending = { messageId: params.messageId, chunks: new Map() };
+            }
+            const prev = pending.chunks.get(params.id) || "";
+            pending.chunks.set(params.id, prev + (params.parametersChunk || ""));
+            if (!timer) {
+                timer = setTimeout(() => {
+                    timer = null;
+                    fire();
+                }, wait);
+            }
+            return;
+        }
+        // start / running — one-shot snapshots applied immediately. Drop this
+        // tool's buffered streaming deltas first: start/running carry the
+        // authoritative parameters, and a pending timer would otherwise fire late
+        // with a stale `streaming` event, regressing this tool block's stage back
+        // to streaming (yellow dot -> gray) mid-execution. Other tools' in-flight
+        // chunks are kept so interleaved multi-tool streaming still accumulates.
+        if (pending) {
+            pending.chunks.delete(params.id);
+            if (pending.chunks.size === 0) {
+                pending = null;
+                if (timer) {
+                    clearTimeout(timer);
+                    timer = null;
+                }
+            }
+        }
+        fn(params);
+    };
+    throttled.cancel = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        pending = null;
+    };
+    throttled.flush = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        fire();
+    };
+    return throttled;
+}
 export const ChatProvider = ({ children, bypassPermissions, permissionMode: initialPermissionMode, pluginDirs, additionalDirectories, tools, allowedTools, disallowedTools, workdir, worktreeSession, originalCwd, version, model, mcpServers, }) => {
     const { restoreSessionId, continueLastSession } = useAppConfig();
     const { stdout } = useStdout();
@@ -142,8 +221,8 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
             };
         }));
     }, 500), []);
-    const throttledToolBlockUpdate = useMemo(() => throttle((params) => {
-        const { messageId, id: toolBlockId, ...updates } = params;
+    const throttledToolBlockUpdate = useMemo(() => createToolStreamingThrottle((params) => {
+        const { messageId, id: toolBlockId, parametersChunk, ...updates } = params;
         setMessages((prev) => prev.map((m) => {
             if (m.id !== messageId)
                 return m;
@@ -158,7 +237,7 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                             id: toolBlockId,
                             name: updates.name || "",
                             stage: updates.stage || "start",
-                            parameters: updates.parameters || "",
+                            parameters: (updates.parameters || "") + (parametersChunk || ""),
                             result: updates.result || "",
                             ...updates,
                         },
@@ -168,7 +247,18 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
             return {
                 ...m,
                 blocks: m.blocks.map((b, idx) => idx === toolBlockIndex && b.type === "tool"
-                    ? { ...b, ...updates }
+                    ? {
+                        ...b,
+                        ...updates,
+                        // Streaming carries only the delta; append it to the
+                        // accumulated parameters. start/running/end carry the
+                        // authoritative value and replace wholesale.
+                        parameters: parametersChunk
+                            ? (b.parameters || "") + parametersChunk
+                            : updates.parameters !== undefined
+                                ? updates.parameters
+                                : b.parameters,
+                    }
                     : b),
             };
         }));
@@ -204,6 +294,8 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
     const [tasks, setTasks] = useState([]);
     // Command state
     const [slashCommands, setSlashCommands] = useState([]);
+    // Agent definitions (for /agents overlay)
+    const [agentDefinitions, setAgentDefinitions] = useState([]);
     // Permission state
     const [permissionMode, setPermissionModeState] = useState(initialPermissionMode ||
         (bypassPermissions ? "bypassPermissions" : "default"));
@@ -236,7 +328,7 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
         }
     }, []);
     // Permission confirmation methods with queue support
-    const showConfirmation = useCallback(async (toolName, toolInput, suggestedPrefix, hidePersistentOption, planContent, permissionMode) => {
+    const showConfirmation = useCallback(async (toolName, toolInput, suggestedPrefix, hidePersistentOption, planContent, permissionMode, warning) => {
         return new Promise((resolve, reject) => {
             const queueItem = {
                 toolName,
@@ -245,6 +337,7 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 hidePersistentOption,
                 planContent,
                 permissionMode,
+                warning,
                 resolver: resolve,
                 reject,
             };
@@ -355,14 +448,20 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                     }
                     : m));
             },
-            onCompleteBangMessage: (command, exitCode, messageId) => {
+            onCompleteBangMessage: (command, exitCode, messageId, output) => {
                 if (isExpandedRef.current)
                     return;
                 setMessages((prev) => prev.map((m) => m.id === messageId
                     ? {
                         ...m,
                         blocks: m.blocks.map((b, idx) => idx === m.blocks.length - 1 && b.type === "bang"
-                            ? { ...b, command, exitCode, stage: "end" }
+                            ? {
+                                ...b,
+                                command,
+                                exitCode,
+                                stage: "end",
+                                ...(output !== undefined ? { output } : {}),
+                            }
                             : b),
                     }
                     : m));
@@ -418,7 +517,7 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
             // Create the permission callback inside the try block to access showConfirmation
             const permissionCallback = async (context) => {
                 try {
-                    return await showConfirmation(context.toolName, context.toolInput, context.suggestedPrefix, context.hidePersistentOption, context.planContent, context.permissionMode);
+                    return await showConfirmation(context.toolName, context.toolInput, context.suggestedPrefix, context.hidePersistentOption, context.planContent, context.permissionMode, context.warning);
                 }
                 catch {
                     // If confirmation was cancelled or failed, deny the operation
@@ -481,6 +580,9 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
             // Get initial commands
             const agentSlashCommands = agent.getSlashCommands?.() || [];
             setSlashCommands(agentSlashCommands);
+            // Get initial agent definitions
+            const initialAgentDefinitions = agent.getSubagentConfigurations?.() || [];
+            setAgentDefinitions(initialAgentDefinitions);
         }
         catch (error) {
             console.error("Failed to initialize AI manager:", error);
@@ -520,6 +622,7 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
         setMessages([]);
         setMcpServerStatuses([]);
         setSlashCommands([]);
+        setAgentDefinitions([]);
         setSessionId("");
         setIsLoading(false);
         setLatestTotalTokens(0);
@@ -706,6 +809,7 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 hidePersistentOption: next.hidePersistentOption,
                 planContent: next.planContent,
                 permissionMode: next.permissionMode,
+                warning: next.warning,
             });
             setIsConfirmationVisible(true);
             setConfirmationQueue((prev) => prev.slice(1));
@@ -841,6 +945,7 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
         stopBackgroundTask,
         slashCommands,
         hasSlashCommand,
+        agentDefinitions,
         permissionMode,
         setPermissionMode,
         isConfirmationVisible,

package/dist/daemon/commands.d.ts

@@ -0,0 +1,49 @@
+/**
+ * `wave daemon` client subcommands — talk to the wave daemon's unix socket
+ * (JSON-RPC over newline-delimited JSON) to list hosted sessions, inspect
+ * progress, inject messages and respond to pending permission requests.
+ *
+ * All subcommands are non-interactive: results go to stdout, diagnostics to
+ * stderr, and every handler calls process.exit() itself (yargs would fall
+ * through to the TUI otherwise). Every command connects to the fixed default
+ * socket `~/.wave/daemon.sock` — the daemon only runs on remote hosts, so no
+ * `--socket` override is offered (spec: daemon-command.md).
+ *
+ * Attach semantics: `initialize {workdir, restoreSessionId}` + `restoreSession`
+ * re-attach to a live session in the daemon's in-memory registry, or reload a
+ * transcript from disk under the current working directory. A session that is
+ * nowhere (live registry or disk) silently starts a FRESH session under a
+ * different id — the only reliable existence check is the `restoreSession`
+ * rejection ("Session not found: <id>"), after which the junk fresh session
+ * must be destroyed via the envelope sessionId returned by `initialize`.
+ */
+/** Fixed default daemon socket (spec: 默认 socket 固定，无 --socket 覆盖). */
+export declare const DEFAULT_DAEMON_SOCKET: string;
+export declare function daemonListCommand(socketPath: string): Promise<void>;
+export declare function daemonStatusCommand(socketPath: string, sessionId: string, lines?: number): Promise<void>;
+export interface SendOptions {
+    timeout: number;
+}
+/**
+ * Send a message and wait for the reply that corresponds to it.
+ *
+ * Completion detection: `sendMessage` on an idle session resolves only after
+ * the whole turn finishes (InteractionService awaits sendAIMessage), while on a
+ * busy session it enqueues and returns immediately — so stopping on a bare
+ * `loadingChange:false` would exit early on the PREVIOUS turn's completion when
+ * queued behind a busy session. Instead, track the message IDs: `ourUserMessage`
+ * is the user message added when OUR turn starts (userMessageAdded), and the
+ * reply is the last assistantMessageAdded observed after it. A stale
+ * loading:false can then never satisfy the wait condition early (the reply has
+ * not been added yet).
+ */
+export declare function daemonSendCommand(socketPath: string, sessionId: string, message: string, options?: SendOptions): Promise<void>;
+export interface RespondOptions {
+    allow?: boolean;
+    deny?: boolean;
+    reason?: string;
+    answer?: string;
+    rule?: string;
+    mode?: string;
+}
+export declare function daemonRespondCommand(socketPath: string, sessionId: string, requestId: string, options: RespondOptions): Promise<void>;

package/dist/daemon/commands.js

@@ -0,0 +1,341 @@
+/**
+ * `wave daemon` client subcommands — talk to the wave daemon's unix socket
+ * (JSON-RPC over newline-delimited JSON) to list hosted sessions, inspect
+ * progress, inject messages and respond to pending permission requests.
+ *
+ * All subcommands are non-interactive: results go to stdout, diagnostics to
+ * stderr, and every handler calls process.exit() itself (yargs would fall
+ * through to the TUI otherwise). Every command connects to the fixed default
+ * socket `~/.wave/daemon.sock` — the daemon only runs on remote hosts, so no
+ * `--socket` override is offered (spec: daemon-command.md).
+ *
+ * Attach semantics: `initialize {workdir, restoreSessionId}` + `restoreSession`
+ * re-attach to a live session in the daemon's in-memory registry, or reload a
+ * transcript from disk under the current working directory. A session that is
+ * nowhere (live registry or disk) silently starts a FRESH session under a
+ * different id — the only reliable existence check is the `restoreSession`
+ * rejection ("Session not found: <id>"), after which the junk fresh session
+ * must be destroyed via the envelope sessionId returned by `initialize`.
+ */
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { ASK_USER_QUESTION_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, getMessageContent, } from "wave-agent-sdk";
+import { SocketClient } from "./socketClient.js";
+/** Fixed default daemon socket (spec: 默认 socket 固定，无 --socket 覆盖). */
+export const DEFAULT_DAEMON_SOCKET = path.join(os.homedir(), ".wave", "daemon.sock");
+const PERMISSION_MODES = [
+    "default",
+    "bypassPermissions",
+    "acceptEdits",
+    "plan",
+    "dontAsk",
+];
+// ── Connection helpers ─────────────────────────────────────────
+function connectDaemon(socketPath) {
+    return new Promise((resolve, reject) => {
+        const socket = net.createConnection(socketPath);
+        socket.once("connect", () => resolve(new SocketClient(socket)));
+        socket.once("error", (err) => {
+            socket.destroy();
+            reject(err);
+        });
+    });
+}
+/** Connect or fail fast with the spec'd error; daemon idle-exits after 60s. */
+async function connectDaemonOrExit(socketPath) {
+    try {
+        return await connectDaemon(socketPath);
+    }
+    catch (err) {
+        const code = err.code;
+        console.error(`无法连接 daemon socket ${socketPath}：daemon 未运行？（daemon 空闲 60 秒自动退出）` +
+            (code ? ` (${code})` : ""));
+        process.exit(1);
+    }
+}
+function fail(message) {
+    console.error(message);
+    process.exit(1);
+}
+/**
+ * Attach to a session; returns the initialized sessionId + working directory.
+ * Exits (nonzero) with the spec'd error when the session exists neither in the
+ * daemon registry nor on disk, destroying the fresh session that `initialize`
+ * silently created.
+ */
+async function attachSession(client, sessionId) {
+    const init = (await client.request("initialize", {
+        workdir: process.cwd(),
+        restoreSessionId: sessionId,
+    }));
+    const initId = init.sessionId;
+    try {
+        await client.request("restoreSession", { sessionId }, initId);
+    }
+    catch (err) {
+        if (err.message.includes("Session not found")) {
+            // initialize silently started a junk fresh session — remove it from the
+            // registry so the failed attach leaves no trace (spec: 会话不存在错误).
+            await client.request("destroy", undefined, initId).catch(() => { });
+            fail(`会话不存在或未被该 daemon 托管：${sessionId}`);
+        }
+        throw err;
+    }
+    return init;
+}
+async function listPendingPermissions(client) {
+    const result = (await client.request("listPendingPermissions"));
+    return result.requests ?? [];
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ── list ───────────────────────────────────────────────────────
+export async function daemonListCommand(socketPath) {
+    let client;
+    try {
+        client = await connectDaemonOrExit(socketPath);
+        const result = (await client.request("listDaemonSessions"));
+        const sessions = result.sessions ?? [];
+        if (sessions.length > 0) {
+            const rows = sessions.map((s) => ({
+                sessionId: s.sessionId,
+                status: s.isLoading ? "生成中" : "空闲",
+                messageCount: String(s.messageCount),
+                workingDirectory: s.workingDirectory,
+            }));
+            const width = (key) => Math.max(...rows.map((r) => r[key].length), key.length);
+            const pad = (value, w) => value.padEnd(w);
+            console.log(`${pad("会话", width("sessionId"))}  ${pad("状态", width("status"))}  ${pad("消息数", width("messageCount"))}  工作目录`);
+            for (const r of rows) {
+                console.log(`${pad(r.sessionId, width("sessionId"))}  ${pad(r.status, width("status"))}  ${pad(r.messageCount, width("messageCount"))}  ${r.workingDirectory}`);
+            }
+        }
+        else {
+            // Daemon idle-exit is normal — an empty registry is not an error.
+            console.log("无会话");
+        }
+    }
+    catch (err) {
+        fail(`wave daemon list 失败：${err.message}`);
+    }
+    finally {
+        await client?.dispose();
+    }
+    // Exits outside the try so the success path's exit is never re-wrapped by the
+    // error handler above.
+    process.exit(0);
+}
+// ── status ─────────────────────────────────────────────────────
+function summarizeToolInput(context) {
+    const input = context.toolInput;
+    if (!input || Object.keys(input).length === 0)
+        return "";
+    let text;
+    try {
+        text = JSON.stringify(input);
+    }
+    catch {
+        text = "";
+    }
+    return text.length > 80 ? `${text.slice(0, 80)}…` : text;
+}
+export async function daemonStatusCommand(socketPath, sessionId, lines = 20) {
+    let client;
+    try {
+        client = await connectDaemonOrExit(socketPath);
+        // Subscribe BEFORE initialize/restoreSession so the replayed loadingChange
+        // snapshot is captured (spec: 依据重放的 loadingChange 快照显示状态).
+        let loading = false;
+        client.onNotification("loadingChange", (params) => {
+            loading = params.loading;
+        });
+        const init = await attachSession(client, sessionId);
+        const initId = init.sessionId;
+        // listPendingPermissions is the authoritative "waiting for approval" signal
+        // (spec: 单凭消息无法区分等审批与执行中，须结合 listPendingPermissions).
+        const pending = (await listPendingPermissions(client)).filter((r) => r.sessionId === initId || r.sessionId === sessionId);
+        const messages = (await client.request("getMessages", undefined, initId));
+        const status = pending.length > 0 ? "等待审批" : loading ? "生成中" : "空闲";
+        console.log(`会话: ${initId}`);
+        console.log(`工作目录: ${init.workingDirectory}`);
+        console.log(`状态: ${status}`);
+        if (pending.length > 0) {
+            console.log("");
+            console.log("待审批请求:");
+            for (const r of pending) {
+                const params = summarizeToolInput(r.context);
+                console.log(`  ${r.requestId}  ${r.context.toolName}${params ? `  ${params}` : ""}`);
+            }
+        }
+        const recent = messages.messages.slice(-lines);
+        if (recent.length > 0) {
+            console.log("");
+            console.log(`最近消息 (${recent.length}):`);
+            for (const m of recent) {
+                const text = getMessageContent(m).replace(/\s+/g, " ").trim();
+                if (!text)
+                    continue; // tool-only messages carry no readable text
+                console.log(`  [${m.role}] ${text}`);
+            }
+        }
+    }
+    catch (err) {
+        fail(`wave daemon status 失败：${err.message}`);
+    }
+    finally {
+        await client?.dispose();
+    }
+    process.exit(0);
+}
+/**
+ * Send a message and wait for the reply that corresponds to it.
+ *
+ * Completion detection: `sendMessage` on an idle session resolves only after
+ * the whole turn finishes (InteractionService awaits sendAIMessage), while on a
+ * busy session it enqueues and returns immediately — so stopping on a bare
+ * `loadingChange:false` would exit early on the PREVIOUS turn's completion when
+ * queued behind a busy session. Instead, track the message IDs: `ourUserMessage`
+ * is the user message added when OUR turn starts (userMessageAdded), and the
+ * reply is the last assistantMessageAdded observed after it. A stale
+ * loading:false can then never satisfy the wait condition early (the reply has
+ * not been added yet).
+ */
+export async function daemonSendCommand(socketPath, sessionId, message, options = { timeout: 600 }) {
+    // connectDaemonOrExit exits on failure — no client to dispose in that case.
+    const client = await connectDaemonOrExit(socketPath);
+    let loading = false;
+    let sent = false;
+    let ourUserMessageId;
+    let replyMessageId;
+    client.onNotification("userMessageAdded", (params) => {
+        if (!sent)
+            return; // ignore messages added during attach
+        ourUserMessageId = params.message.id;
+    });
+    client.onNotification("assistantMessageAdded", (params) => {
+        if (!sent || ourUserMessageId === undefined)
+            return; // not our turn yet
+        replyMessageId = params.message.id;
+    });
+    client.onNotification("loadingChange", (params) => {
+        loading = params.loading;
+    });
+    let initId;
+    try {
+        initId = (await attachSession(client, sessionId)).sessionId;
+        sent = true;
+        await client.request("sendMessage", { text: message }, initId);
+    }
+    catch (err) {
+        client.dispose();
+        fail(`wave daemon send 失败：${err.message}`);
+    }
+    // Wait for the reply that corresponds to our message.
+    const started = Date.now();
+    const timeoutMs = options.timeout === 0 ? Infinity : options.timeout * 1000;
+    while (!(loading === false && replyMessageId !== undefined)) {
+        if (Date.now() - started > timeoutMs) {
+            // Timeout backstop: the most likely cause is a session waiting on a
+            // permission approval — point the user at respond (spec: 不无限期挂起).
+            const pending = (await listPendingPermissions(client)).filter((r) => r.sessionId === sessionId || r.sessionId === initId);
+            client.dispose();
+            if (pending.length > 0) {
+                fail(`会话等待权限审批，请通过 \`wave daemon respond ${sessionId} ${pending[0].requestId}\` 处理后重试`);
+            }
+            fail(options.timeout === 0
+                ? "等待回复超时"
+                : `等待回复超时（${options.timeout} 秒），未收到助手回复`);
+        }
+        await sleep(200);
+    }
+    try {
+        const result = (await client.request("getMessages", undefined, initId));
+        const reply = result.messages.find((m) => m.id === replyMessageId);
+        // Pure final-reply text only; streaming deltas / subagent internals never
+        // reach stdout (spec: send 输出纯净性).
+        if (reply) {
+            const content = getMessageContent(reply).replace(/\s+/g, " ").trim();
+            if (content)
+                console.log(content);
+        }
+    }
+    catch (err) {
+        fail(`wave daemon send 失败：${err.message}`);
+    }
+    finally {
+        client.dispose();
+    }
+    process.exit(0);
+}
+export async function daemonRespondCommand(socketPath, sessionId, requestId, options) {
+    if (!!options.allow === !!options.deny) {
+        fail("请指定 --allow 或 --deny（二选一）");
+    }
+    let client;
+    try {
+        client = await connectDaemonOrExit(socketPath);
+        // The server silently ignores permissionResponse for unknown requestIds —
+        // validate first so the user is never misled into thinking approval landed.
+        const pending = await listPendingPermissions(client);
+        const req = pending.find((r) => r.requestId === requestId);
+        if (!req) {
+            fail("该请求不存在或已处理");
+        }
+        if (req.sessionId && req.sessionId !== sessionId) {
+            // Cross-check before notifying; never touch another session's request.
+            fail("会话不存在或未被该 daemon 托管");
+        }
+        let decision;
+        if (options.deny) {
+            decision = { behavior: "deny", message: options.reason };
+        }
+        else {
+            // Per-tool auto-completion, mirroring the desktop ConfirmationDialog
+            // semantics (spec: 决策并非单一 allow/deny，须按工具智能补全).
+            const toolName = req.context.toolName;
+            if (toolName === ENTER_PLAN_MODE_TOOL_NAME) {
+                decision = { behavior: "allow", newPermissionMode: "plan" };
+            }
+            else if (toolName === EXIT_PLAN_MODE_TOOL_NAME) {
+                decision = { behavior: "allow", newPermissionMode: "default" };
+            }
+            else if (toolName === ASK_USER_QUESTION_TOOL_NAME) {
+                if (!options.answer) {
+                    fail("AskUserQuestion 请求需要 --answer 提供答案 JSON");
+                }
+                let answers;
+                try {
+                    answers = JSON.parse(options.answer);
+                }
+                catch {
+                    fail("--answer 不是合法的 JSON");
+                }
+                decision = { behavior: "allow", message: JSON.stringify(answers) };
+            }
+            else {
+                decision = { behavior: "allow" };
+            }
+            if (options.rule)
+                decision.newPermissionRule = options.rule;
+            if (options.mode) {
+                if (!PERMISSION_MODES.includes(options.mode)) {
+                    fail(`无效的权限模式：${options.mode}（可选：${PERMISSION_MODES.join("、")}）`);
+                }
+                decision.newPermissionMode = options.mode;
+            }
+        }
+        // Mirror desktop stdioAgent.sendPermissionResponse: envelope sessionId
+        // present, decision built from the pending request's tool.
+        client.notify("permissionResponse", { requestId, decision }, sessionId);
+        console.log(`已处理审批请求：${requestId}`);
+    }
+    catch (err) {
+        fail(`wave daemon respond 失败：${err.message}`);
+    }
+    finally {
+        await client?.dispose();
+    }
+    process.exit(0);
+}

package/dist/daemon/jsonRpcClient.d.ts

@@ -0,0 +1,38 @@
+/**
+ * JsonRpcClient — minimal JSON-RPC transport over a line-delimited duplex
+ * stream (one JSON object per line).
+ *
+ * Used by `wave daemon` subcommands to talk to the wave daemon's unix socket.
+ * Mirrors packages/desktop/src/main/stdio/jsonRpcClient.ts (packages/code
+ * cannot import from packages/desktop). Subclasses own the transport and hook
+ * in:
+ * - `writeLine(message)` writes one JSON line to the peer.
+ * - `attachReadable(readable)` wires the inbound half (socket).
+ * - `handleClosed(reason)` marks the transport dead and rejects every pending
+ *   request. Idempotent — safe to call from both dispose() and an exit/close
+ *   event on the underlying transport.
+ */
+import type { Readable } from "stream";
+export type NotificationHandler = (params: unknown, sessionId?: string) => void;
+export declare abstract class JsonRpcClient {
+    private nextId;
+    private pending;
+    private handlers;
+    private closedHandlers;
+    private closed;
+    protected abstract writeLine(message: string): void;
+    /** Wire an inbound Readable (socket) to the line parser. */
+    protected attachReadable(readable: Readable): void;
+    /** Mark the transport closed: reject every pending request. Idempotent. */
+    protected handleClosed(reason: string): void;
+    protected get isClosed(): boolean;
+    /** Close the transport and reject pending requests (subclass tears down its stream). */
+    abstract dispose(): void;
+    /** Observe transport teardown (dispose or unexpected close), fired once. */
+    onClosed(handler: () => void): void;
+    request(method: string, params?: unknown, sessionId?: string): Promise<unknown>;
+    notify(method: string, params?: unknown, sessionId?: string): void;
+    onNotification(method: string, handler: NotificationHandler): void;
+    offNotification(method: string, handler: NotificationHandler): void;
+    private handleLine;
+}