wave-code 1.0.6 → 1.0.8

package/dist/daemon/jsonRpcClient.js

@@ -0,0 +1,129 @@
+/**
+ * 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 { createInterface } from "readline";
+export class JsonRpcClient {
+    constructor() {
+        this.nextId = 1;
+        this.pending = new Map();
+        this.handlers = new Map();
+        this.closedHandlers = [];
+        this.closed = false;
+    }
+    /** Wire an inbound Readable (socket) to the line parser. */
+    attachReadable(readable) {
+        const rl = createInterface({ input: readable });
+        rl.on("line", (line) => this.handleLine(line));
+        // readline re-emits input errors on the Interface; the transport subclass
+        // already handles errors on the underlying stream, swallow them here so
+        // they never surface as an uncaught 'error' on the Interface.
+        rl.on("error", () => { });
+    }
+    /** Mark the transport closed: reject every pending request. Idempotent. */
+    handleClosed(reason) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const error = new Error(reason);
+        for (const p of this.pending.values())
+            p.reject(error);
+        this.pending.clear();
+        for (const handler of this.closedHandlers)
+            handler();
+        this.closedHandlers = [];
+    }
+    get isClosed() {
+        return this.closed;
+    }
+    /** Observe transport teardown (dispose or unexpected close), fired once. */
+    onClosed(handler) {
+        this.closedHandlers.push(handler);
+    }
+    async request(method, params, sessionId) {
+        if (this.closed) {
+            throw new Error("连接已断开。wave 进程已退出，请重启编辑器或检查 CLI 安装。");
+        }
+        const id = this.nextId++;
+        const envelope = { id, method, params };
+        if (sessionId)
+            envelope.sessionId = sessionId;
+        const message = JSON.stringify(envelope) + "\n";
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.writeLine(message);
+        });
+    }
+    notify(method, params, sessionId) {
+        if (this.closed)
+            return;
+        const envelope = { method, params };
+        if (sessionId)
+            envelope.sessionId = sessionId;
+        this.writeLine(JSON.stringify(envelope) + "\n");
+    }
+    onNotification(method, handler) {
+        let set = this.handlers.get(method);
+        if (!set) {
+            set = new Set();
+            this.handlers.set(method, set);
+        }
+        set.add(handler);
+    }
+    offNotification(method, handler) {
+        this.handlers.get(method)?.delete(handler);
+    }
+    // ── Internal ──────────────────────────────────────────────────
+    handleLine(line) {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            console.error("[wave-jsonrpc] Failed to parse:", line);
+            return;
+        }
+        if (typeof msg !== "object" || msg === null)
+            return;
+        const obj = msg;
+        // Response (has id + result/error)
+        if ("id" in obj && ("result" in obj || "error" in obj)) {
+            const id = Number(obj.id);
+            const pending = this.pending.get(id);
+            if (pending) {
+                this.pending.delete(id);
+                if (obj.error) {
+                    const err = obj.error;
+                    pending.reject(new Error(err.message));
+                }
+                else {
+                    pending.resolve(obj.result);
+                }
+            }
+            return;
+        }
+        // Notification (has method, no id)
+        if ("method" in obj && !("id" in obj)) {
+            const method = obj.method;
+            const params = obj.params;
+            const sessionId = typeof obj.sessionId === "string" ? obj.sessionId : undefined;
+            const set = this.handlers.get(method);
+            if (set) {
+                for (const handler of set) {
+                    handler(params, sessionId);
+                }
+            }
+            return;
+        }
+    }
+}

package/dist/daemon/socketClient.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SocketClient — JSON-RPC transport over a unix socket connection to the wave
+ * daemon. Mirrors packages/desktop/src/main/stdio/socketClient.ts (packages/code
+ * cannot import from packages/desktop).
+ */
+import type { Socket } from "net";
+import { JsonRpcClient } from "./jsonRpcClient.js";
+export declare class SocketClient extends JsonRpcClient {
+    private socket;
+    constructor(socket: Socket);
+    protected writeLine(message: string): void;
+    dispose(): void;
+}

package/dist/daemon/socketClient.js

@@ -0,0 +1,26 @@
+/**
+ * SocketClient — JSON-RPC transport over a unix socket connection to the wave
+ * daemon. Mirrors packages/desktop/src/main/stdio/socketClient.ts (packages/code
+ * cannot import from packages/desktop).
+ */
+import { JsonRpcClient } from "./jsonRpcClient.js";
+export class SocketClient extends JsonRpcClient {
+    constructor(socket) {
+        super();
+        this.socket = socket;
+        this.attachReadable(socket);
+        socket.on("close", () => {
+            this.handleClosed("远端连接已断开。");
+        });
+        socket.on("error", (err) => {
+            console.error("[wave-daemon] Socket error:", err.message);
+        });
+    }
+    writeLine(message) {
+        this.socket.write(message);
+    }
+    dispose() {
+        this.handleClosed("远端连接已断开。");
+        this.socket.destroy();
+    }
+}

package/dist/hooks/useInputManager.d.ts

@@ -16,6 +16,7 @@ export declare const useInputManager: (callbacks?: Partial<InputManagerCallbacks
     historySearchQuery: string;
     showBackgroundTaskManager: boolean;
     showMcpManager: boolean;
+    showAgentsManager: boolean;
     showRewindManager: boolean;
     showHelp: boolean;
     showStatusCommand: boolean;
@@ -49,6 +50,7 @@ export declare const useInputManager: (callbacks?: Partial<InputManagerCallbacks
     processSelectorInput: (char: string) => void;
     setShowBackgroundTaskManager: (show: boolean) => void;
     setShowMcpManager: (show: boolean) => void;
+    setShowAgentsManager: (show: boolean) => void;
     setShowRewindManager: (show: boolean) => void;
     setShowHelp: (show: boolean) => void;
     setShowStatusCommand: (show: boolean) => void;

package/dist/hooks/useInputManager.js

@@ -174,6 +174,9 @@ export const useInputManager = (callbacks = {}) => {
                             else if (command === "mcp") {
                                 dispatch({ type: "SET_SHOW_MCP_MANAGER", payload: true });
                             }
+                            else if (command === "agents") {
+                                dispatch({ type: "SET_SHOW_AGENTS_MANAGER", payload: true });
+                            }
                             else if (command === "rewind") {
                                 dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: true });
                             }
@@ -378,6 +381,9 @@ export const useInputManager = (callbacks = {}) => {
     const setShowMcpManager = useCallback((show) => {
         dispatch({ type: "SET_SHOW_MCP_MANAGER", payload: show });
     }, []);
+    const setShowAgentsManager = useCallback((show) => {
+        dispatch({ type: "SET_SHOW_AGENTS_MANAGER", payload: show });
+    }, []);
     const setShowRewindManager = useCallback((show) => {
         dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: show });
     }, []);
@@ -506,6 +512,7 @@ export const useInputManager = (callbacks = {}) => {
         historySearchQuery: state.historySearchQuery,
         showBackgroundTaskManager: state.showBackgroundTaskManager,
         showMcpManager: state.showMcpManager,
+        showAgentsManager: state.showAgentsManager,
         showRewindManager: state.showRewindManager,
         showHelp: state.showHelp,
         showStatusCommand: state.showStatusCommand,
@@ -545,6 +552,7 @@ export const useInputManager = (callbacks = {}) => {
         // Bash/MCP Manager
         setShowBackgroundTaskManager,
         setShowMcpManager,
+        setShowAgentsManager,
         setShowRewindManager,
         setShowHelp,
         setShowStatusCommand,

package/dist/index.js

@@ -178,6 +178,94 @@ export async function main() {
                 const { updatePluginCommand } = await import("./commands/plugin/update.js");
                 await updatePluginCommand(argv);
             });
+        })
+            .command("daemon", "Manage the wave daemon (client subcommands — to START a daemon use `wave --daemon <socket>` instead)", (yargs) => {
+            return yargs
+                .help()
+                .command("list", "List sessions hosted by the daemon (in-memory registry)", {}, async () => {
+                const { daemonListCommand, DEFAULT_DAEMON_SOCKET } = await import("./daemon/commands.js");
+                await daemonListCommand(DEFAULT_DAEMON_SOCKET);
+            })
+                .command("status <sessionId>", "Show a session's progress and recent messages", (yargs) => {
+                return yargs
+                    .positional("sessionId", {
+                    describe: "Session ID hosted by the daemon",
+                    type: "string",
+                })
+                    .option("lines", {
+                    describe: "Number of recent messages to show",
+                    default: 20,
+                    type: "number",
+                });
+            }, async (argv) => {
+                const { daemonStatusCommand, DEFAULT_DAEMON_SOCKET } = await import("./daemon/commands.js");
+                await daemonStatusCommand(DEFAULT_DAEMON_SOCKET, argv.sessionId, argv.lines);
+            })
+                .command("send <sessionId> <message>", "Inject a message into a session and wait for the reply", (yargs) => {
+                return yargs
+                    .positional("sessionId", {
+                    describe: "Session ID hosted by the daemon",
+                    type: "string",
+                })
+                    .positional("message", {
+                    describe: "Message to send",
+                    type: "string",
+                })
+                    .option("timeout", {
+                    describe: "Seconds to wait for the reply (0 = no limit)",
+                    default: 600,
+                    type: "number",
+                });
+            }, async (argv) => {
+                const { daemonSendCommand, DEFAULT_DAEMON_SOCKET } = await import("./daemon/commands.js");
+                await daemonSendCommand(DEFAULT_DAEMON_SOCKET, argv.sessionId, argv.message, { timeout: argv.timeout });
+            })
+                .command("respond <sessionId> <requestId>", "Respond to a pending permission request", (yargs) => {
+                return yargs
+                    .positional("sessionId", {
+                    describe: "Session ID hosting the pending request",
+                    type: "string",
+                })
+                    .positional("requestId", {
+                    describe: "Pending permission request ID",
+                    type: "string",
+                })
+                    .option("allow", {
+                    describe: "Allow the operation",
+                    type: "boolean",
+                })
+                    .option("deny", {
+                    describe: "Deny the operation",
+                    type: "boolean",
+                })
+                    .option("reason", {
+                    describe: "Reason for the decision (deny)",
+                    type: "string",
+                })
+                    .option("answer", {
+                    describe: "Answers JSON for AskUserQuestion requests",
+                    type: "string",
+                })
+                    .option("rule", {
+                    describe: "Persist an allowed rule (e.g. Bash(ls))",
+                    type: "string",
+                })
+                    .option("mode", {
+                    describe: "Switch the session's permission mode",
+                    type: "string",
+                });
+            }, async (argv) => {
+                const { daemonRespondCommand, DEFAULT_DAEMON_SOCKET } = await import("./daemon/commands.js");
+                await daemonRespondCommand(DEFAULT_DAEMON_SOCKET, argv.sessionId, argv.requestId, {
+                    allow: argv.allow,
+                    deny: argv.deny,
+                    reason: argv.reason,
+                    answer: argv.answer,
+                    rule: argv.rule,
+                    mode: argv.mode,
+                });
+            })
+                .demandCommand(1, "Please specify a daemon subcommand");
         })
             .command("update", "Update WAVE Code to the latest version", {}, async () => {
             const { updateCommand } = await import("./commands/update.js");

package/dist/managers/inputHandlers.js

@@ -264,6 +264,9 @@ export const handleCommandSelect = (state, dispatch, callbacks, command) => {
                 else if (command === "mcp") {
                     dispatch({ type: "SET_SHOW_MCP_MANAGER", payload: true });
                 }
+                else if (command === "agents") {
+                    dispatch({ type: "SET_SHOW_AGENTS_MANAGER", payload: true });
+                }
                 else if (command === "rewind") {
                     dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: true });
                 }

package/dist/managers/inputReducer.d.ts

@@ -111,6 +111,7 @@ export interface InputState {
     imageIdCounter: number;
     showBackgroundTaskManager: boolean;
     showMcpManager: boolean;
+    showAgentsManager: boolean;
     showRewindManager: boolean;
     showHelp: boolean;
     showStatusCommand: boolean;
@@ -187,6 +188,9 @@ export type InputAction = {
 } | {
     type: "SET_SHOW_MCP_MANAGER";
     payload: boolean;
+} | {
+    type: "SET_SHOW_AGENTS_MANAGER";
+    payload: boolean;
 } | {
     type: "SET_SHOW_REWIND_MANAGER";
     payload: boolean;

package/dist/managers/inputReducer.js

@@ -26,6 +26,7 @@ export const initialState = {
     imageIdCounter: 1,
     showBackgroundTaskManager: false,
     showMcpManager: false,
+    showAgentsManager: false,
     showRewindManager: false,
     showHelp: false,
     showStatusCommand: false,
@@ -347,6 +348,12 @@ export function inputReducer(state, action) {
                 showMcpManager: action.payload,
                 selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
             };
+        case "SET_SHOW_AGENTS_MANAGER":
+            return {
+                ...state,
+                showAgentsManager: action.payload,
+                selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
+            };
         case "SET_SHOW_REWIND_MANAGER":
             return {
                 ...state,
@@ -695,6 +702,7 @@ export function inputReducer(state, action) {
                 }
                 if (!(state.showBackgroundTaskManager ||
                     state.showMcpManager ||
+                    state.showAgentsManager ||
                     state.showRewindManager ||
                     state.showHelp ||
                     state.showStatusCommand ||

package/dist/reducers/agentsManagerReducer.d.ts

@@ -0,0 +1,26 @@
+import { Key } from "ink";
+export type PendingEffect = {
+    type: "CANCEL";
+};
+export interface AgentsManagerState {
+    selectedIndex: number;
+    viewMode: "list" | "detail";
+    pendingEffect: PendingEffect | null;
+}
+export type AgentsManagerAction = {
+    type: "MOVE_UP";
+} | {
+    type: "MOVE_DOWN";
+    itemCount: number;
+} | {
+    type: "SET_VIEW_MODE";
+    viewMode: "list" | "detail";
+} | {
+    type: "HANDLE_KEY";
+    input: string;
+    key: Key;
+    itemCount: number;
+} | {
+    type: "CLEAR_PENDING_EFFECT";
+};
+export declare function agentsManagerReducer(state: AgentsManagerState, action: AgentsManagerAction): AgentsManagerState;

package/dist/reducers/agentsManagerReducer.js

@@ -0,0 +1,54 @@
+export function agentsManagerReducer(state, action) {
+    switch (action.type) {
+        case "MOVE_UP":
+            return {
+                ...state,
+                selectedIndex: Math.max(0, state.selectedIndex - 1),
+            };
+        case "MOVE_DOWN":
+            return {
+                ...state,
+                selectedIndex: Math.min(Math.max(0, action.itemCount - 1), state.selectedIndex + 1),
+            };
+        case "SET_VIEW_MODE":
+            return { ...state, viewMode: action.viewMode };
+        case "HANDLE_KEY": {
+            const { key, itemCount } = action;
+            if (key.return) {
+                if (state.viewMode === "list") {
+                    return { ...state, viewMode: "detail" };
+                }
+                // Aligned with Claude Code AgentDetail: Enter returns to the list.
+                return { ...state, viewMode: "list" };
+            }
+            if (key.escape) {
+                if (state.viewMode === "detail") {
+                    return { ...state, viewMode: "list" };
+                }
+                return { ...state, pendingEffect: { type: "CANCEL" } };
+            }
+            // Detail view does not respond to arrow keys (aligned with CC
+            // AgentDetail, which only Esc/Enter back to the list).
+            if (state.viewMode === "detail") {
+                return state;
+            }
+            if (key.upArrow) {
+                return {
+                    ...state,
+                    selectedIndex: Math.max(0, state.selectedIndex - 1),
+                };
+            }
+            if (key.downArrow) {
+                return {
+                    ...state,
+                    selectedIndex: Math.min(Math.max(0, itemCount - 1), state.selectedIndex + 1),
+                };
+            }
+            return state;
+        }
+        case "CLEAR_PENDING_EFFECT":
+            return { ...state, pendingEffect: null };
+        default:
+            return state;
+    }
+}

package/dist/stdio/agentBridge.d.ts

@@ -56,7 +56,18 @@ export declare class AgentBridge {
     private removeWorktreeSession;
     private getSessionInfo;
     private updateConfig;
+    private getConfiguredModels;
+    private setModel;
     private sendMessage;
+    /**
+     * Webview hosts (desktop/vscode/jetbrains) send pasted images as inline
+     * data URLs — there is no local file behind them. Persist each to a temp
+     * file so the model gets a real path it can reference with tools (aligned
+     * with Claude Code's `[Image source: <path>]` metadata). Real paths pass
+     * through untouched; unparseable data URLs pass through as-is and are
+     * skipped by the SDK rather than blocking the message.
+     */
+    private persistDataUrlImages;
     private bang;
     private askBtw;
     private abortMessage;
@@ -80,6 +91,7 @@ export declare class AgentBridge {
     private connectMcpServer;
     private disconnectMcpServer;
     private getSlashCommands;
+    private getSubagentConfigurations;
     private searchFiles;
     /**
      * Writes an uploaded file (from the desktop/webview "+上传文件" flow) into the
@@ -96,6 +108,9 @@ export declare class AgentBridge {
      * client disconnected (daemon mode). Responding to any listed requestId
      * resolves the in-process promise. */
     private listPendingPermissions;
+    /** Daemon list: expose the in-memory session registry (live sessions only,
+     * not disk-scanning). Registration order is preserved. */
+    private listDaemonSessions;
     private getAuthStatus;
     private login;
     private logout;