wave-code 1.0.7 → 1.0.9

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"