wave-code 1.0.7 → 1.0.8

package/src/daemon/jsonRpcClient.ts

@@ -0,0 +1,158 @@
+/**
+ * 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";
+import type { Readable } from "stream";
+
+export type NotificationHandler = (params: unknown, sessionId?: string) => void;
+
+interface PendingRequest {
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+}
+
+export abstract class JsonRpcClient {
+  private nextId = 1;
+  private pending = new Map<number, PendingRequest>();
+  private handlers = new Map<string, Set<NotificationHandler>>();
+  private closedHandlers: Array<() => void> = [];
+  private closed = false;
+
+  // ── Transport hooks (subclass) ─────────────────────────────────
+
+  protected abstract writeLine(message: string): void;
+
+  /** Wire an inbound Readable (socket) to the line parser. */
+  protected attachReadable(readable: Readable): void {
+    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. */
+  protected handleClosed(reason: string): void {
+    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 = [];
+  }
+
+  protected get isClosed(): boolean {
+    return this.closed;
+  }
+
+  // ── Public API ─────────────────────────────────────────────────
+
+  /** 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 {
+    this.closedHandlers.push(handler);
+  }
+
+  async request(
+    method: string,
+    params?: unknown,
+    sessionId?: string,
+  ): Promise<unknown> {
+    if (this.closed) {
+      throw new Error(
+        "连接已断开。wave 进程已退出，请重启编辑器或检查 CLI 安装。",
+      );
+    }
+    const id = this.nextId++;
+    const envelope: Record<string, unknown> = { 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: string, params?: unknown, sessionId?: string): void {
+    if (this.closed) return;
+    const envelope: Record<string, unknown> = { method, params };
+    if (sessionId) envelope.sessionId = sessionId;
+    this.writeLine(JSON.stringify(envelope) + "\n");
+  }
+
+  onNotification(method: string, handler: NotificationHandler): void {
+    let set = this.handlers.get(method);
+    if (!set) {
+      set = new Set();
+      this.handlers.set(method, set);
+    }
+    set.add(handler);
+  }
+
+  offNotification(method: string, handler: NotificationHandler): void {
+    this.handlers.get(method)?.delete(handler);
+  }
+
+  // ── Internal ──────────────────────────────────────────────────
+
+  private handleLine(line: string): void {
+    let msg: unknown;
+    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 as Record<string, unknown>;
+
+    // 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 as { code: number; message: string };
+          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 as string;
+      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/src/daemon/socketClient.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 class SocketClient extends JsonRpcClient {
+  private socket: Socket;
+
+  constructor(socket: 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);
+    });
+  }
+
+  protected writeLine(message: string): void {
+    this.socket.write(message);
+  }
+
+  dispose(): void {
+    this.handleClosed("远端连接已断开。");
+    this.socket.destroy();
+  }
+}

package/src/index.ts

@@ -252,6 +252,136 @@ export async function main() {
             },
           );
       })
+      .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 as string,
+                  argv.lines as number,
+                );
+              },
+            )
+            .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 as string,
+                  argv.message as string,
+                  { timeout: argv.timeout as number },
+                );
+              },
+            )
+            .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 as string,
+                  argv.requestId as string,
+                  {
+                    allow: argv.allow as boolean | undefined,
+                    deny: argv.deny as boolean | undefined,
+                    reason: argv.reason as string | undefined,
+                    answer: argv.answer as string | undefined,
+                    rule: argv.rule as string | undefined,
+                    mode: argv.mode as string | undefined,
+                  },
+                );
+              },
+            )
+            .demandCommand(1, "Please specify a daemon subcommand");
+        },
+      )
       .command(
         "update",
         "Update WAVE Code to the latest version",

package/src/stdio/agentBridge.ts

@@ -175,6 +175,8 @@ export class AgentBridge {
         return this.getSessionInfo(sessionId);
       case "listPendingPermissions":
         return this.listPendingPermissions();
+      case "listDaemonSessions":
+        return this.listDaemonSessions();
       case "updateConfig":
         return this.updateConfig(p as unknown as UpdateConfigParams, sessionId);
       case "getConfiguredModels":
@@ -790,10 +792,45 @@ export class AgentBridge {
     } catch {
       // Best-effort; don't block message sending on history save failure
     }
-    await entry.agent.sendMessage(params.text, params.images);
+    await entry.agent.sendMessage(
+      params.text,
+      this.persistDataUrlImages(params.images),
+    );
     return null;
   }
 
+  /**
+   * 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(
+    images?: Array<{ path: string; mimeType: string }>,
+  ): Array<{ path: string; mimeType: string }> | undefined {
+    if (!images || images.length === 0) return images;
+    return images.map((img) => {
+      if (!img.path.startsWith("data:")) return img;
+      const match = /^data:([^;,]+);base64,(.*)$/s.exec(img.path);
+      if (!match) return img;
+      try {
+        const mimeType = match[1];
+        const ext = mimeType.split("/")[1]?.replace("jpeg", "jpg") || "png";
+        const filePath = join(
+          tmpdir(),
+          `wave-image-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${ext}`,
+        );
+        writeFileSync(filePath, Buffer.from(match[2], "base64"));
+        return { path: filePath, mimeType };
+      } catch (error) {
+        logger.warn("Failed to persist pasted image to temp file:", error);
+        return img;
+      }
+    });
+  }
+
   private async bang(command: string, sessionId?: string): Promise<null> {
     const entry = this.requireSession(sessionId);
     await entry.agent.bang(command);
@@ -849,7 +886,10 @@ export class AgentBridge {
   }> {
     const entry = this.requireSession(sessionId);
     const { messages } = await entry.agent.getFullMessageThread();
-    const index = messages.findIndex((m) => m.id === messageId);
+    // 压缩是 append-only：同 id 消息（压缩前历史 + 压缩后 append 的重复）会
+    // 在磁盘完整线程中出现多次。用户看到的折叠视图对应最后一次出现，
+    // 因此匹配最后一个而非第一个，避免回滚时连压缩摘要一起删掉。
+    const index = messages.map((m) => m.id).lastIndexOf(messageId);
     if (index === -1) {
       throw new RpcError(
         PROTOCOL_INTERNAL_ERROR,
@@ -869,13 +909,19 @@ export class AgentBridge {
   }> {
     const entry = this.requireSession(sessionId);
     const { messages } = await entry.agent.getFullMessageThread();
-    const checkpoints = messages
-      .filter((m) => isUserCheckpointMessage(m) && m.id)
-      .map((m) => ({
-        id: m.id as string,
-        content: getMessageContent(m).replace(/\s+/g, " ").trim(),
-      }));
-    return { checkpoints };
+    // 压缩 append-only 后同 id 消息在磁盘完整线程中重复出现（压缩前历史 +
+    // 压缩后 append 的重复）。按 id 去重并保留最后一次出现（与折叠后的
+    // UI/内存视图一致），避免弹窗把同一条用户消息显示两遍。
+    const checkpointMap = new Map<string, { id: string; content: string }>();
+    for (const m of messages) {
+      if (isUserCheckpointMessage(m) && m.id) {
+        checkpointMap.set(m.id, {
+          id: m.id,
+          content: getMessageContent(m).replace(/\s+/g, " ").trim(),
+        });
+      }
+    }
+    return { checkpoints: Array.from(checkpointMap.values()) };
   }
 
   private deleteQueuedMessage(index: number, sessionId?: string): null {
@@ -893,7 +939,7 @@ export class AgentBridge {
     const entry = this.requireSession(sessionId);
     const ok = entry.agent.updateQueuedMessageById(id, {
       content: text,
-      images,
+      images: this.persistDataUrlImages(images),
     });
     return { ok };
   }
@@ -1144,6 +1190,26 @@ export class AgentBridge {
     };
   }
 
+  /** Daemon list: expose the in-memory session registry (live sessions only,
+   * not disk-scanning). Registration order is preserved. */
+  private listDaemonSessions(): {
+    sessions: Array<{
+      sessionId: string;
+      workingDirectory: string;
+      isLoading: boolean;
+      messageCount: number;
+    }>;
+  } {
+    return {
+      sessions: [...this.sessions.entries()].map(([sessionId, entry]) => ({
+        sessionId,
+        workingDirectory: entry.agent.workingDirectory,
+        isLoading: entry.agent.isLoading,
+        messageCount: entry.agent.messages.length,
+      })),
+    };
+  }
+
   // ── Auth (global) ────────────────────────────────────────────
 
   private async getAuthStatus(): Promise<{

package/src/stdio/protocol.ts

@@ -79,6 +79,8 @@ export type RequestMethod =
   | "setModel"
   // Permissions (daemon attach: re-surface pending approvals after reconnect)
   | "listPendingPermissions"
+  // Daemon (global — list in-memory session registry, no session required)
+  | "listDaemonSessions"
   // Auth
   | "getAuthStatus"
   | "login"