wave-code 1.0.6 → 1.0.8

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/managers/inputHandlers.ts

@@ -367,6 +367,8 @@ export const handleCommandSelect = (
           });
         } 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 });
         } else if (command === "help") {

package/src/managers/inputReducer.ts

@@ -130,6 +130,7 @@ export interface InputState {
   imageIdCounter: number;
   showBackgroundTaskManager: boolean;
   showMcpManager: boolean;
+  showAgentsManager: boolean;
   showRewindManager: boolean;
   showHelp: boolean;
   showStatusCommand: boolean;
@@ -167,6 +168,7 @@ export const initialState: InputState = {
   imageIdCounter: 1,
   showBackgroundTaskManager: false,
   showMcpManager: false,
+  showAgentsManager: false,
   showRewindManager: false,
   showHelp: false,
   showStatusCommand: false,
@@ -400,6 +402,7 @@ export type InputAction =
   | { type: "CLEAR_IMAGES" }
   | { type: "SET_SHOW_BACKGROUND_TASK_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_MCP_MANAGER"; payload: boolean }
+  | { type: "SET_SHOW_AGENTS_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_REWIND_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_HELP"; payload: boolean }
   | { type: "SET_SHOW_STATUS_COMMAND"; payload: boolean }
@@ -589,6 +592,12 @@ export function inputReducer(
         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,
@@ -970,6 +979,7 @@ export function inputReducer(
           !(
             state.showBackgroundTaskManager ||
             state.showMcpManager ||
+            state.showAgentsManager ||
             state.showRewindManager ||
             state.showHelp ||
             state.showStatusCommand ||

package/src/reducers/agentsManagerReducer.ts

@@ -0,0 +1,91 @@
+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 function agentsManagerReducer(
+  state: AgentsManagerState,
+  action: AgentsManagerAction,
+): AgentsManagerState {
+  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/src/stdio/agentBridge.ts

@@ -42,6 +42,8 @@ import {
   PluginCore,
   validateWorktreeRemovalPath,
   type SlashCommand,
+  loadUserConfigEnv,
+  type SubagentConfiguration,
 } from "wave-agent-sdk";
 import {
   type JsonRpcError,
@@ -140,6 +142,15 @@ export class AgentBridge {
 
   constructor(options: AgentBridgeOptions) {
     this.emit = options.emit;
+    // Mirror the user-level settings env WAVE_SERVER_URL into process.env
+    // before any agent initializes. getAuthStatus (webviewReady →
+    // pushInitialState) can run before the first agent, and AuthService falls
+    // back to the default URL otherwise — refreshing a custom-domain token
+    // against the wrong host 401s into a logged-out state.
+    const userEnv = loadUserConfigEnv();
+    if (userEnv.WAVE_SERVER_URL) {
+      process.env.WAVE_SERVER_URL = userEnv.WAVE_SERVER_URL;
+    }
   }
 
   // ── Public API ────────────────────────────────────────────────
@@ -164,8 +175,14 @@ 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":
+        return this.getConfiguredModels(sessionId);
+      case "setModel":
+        return this.setModel(p.model as string, sessionId);
 
       // ── Messages ──
       case "sendMessage":
@@ -222,6 +239,8 @@ export class AgentBridge {
       // ── Commands ──
       case "getSlashCommands":
         return this.getSlashCommands(sessionId);
+      case "getSubagentConfigurations":
+        return this.getSubagentConfigurations(sessionId);
 
       // ── File / History (global — no session required) ──
       case "searchFiles":
@@ -727,6 +746,27 @@ export class AgentBridge {
     return { sessionId: agent.sessionId };
   }
 
+  private getConfiguredModels(sessionId?: string): {
+    models: string[];
+    currentModel: string | undefined;
+  } {
+    const entry = this.requireSession(sessionId);
+    return {
+      models: entry.agent.getConfiguredModels(),
+      currentModel: entry.agent.getModelConfig().model,
+    };
+  }
+
+  private async setModel(model: string, sessionId?: string): Promise<null> {
+    const entry = this.requireSession(sessionId);
+    entry.agent.setModel(model);
+    // Keep storedConfig in sync: updateConfig recreates the agent from
+    // storedConfig, so without this a later config save would revert the
+    // model chosen here.
+    entry.storedConfig = { ...entry.storedConfig, model };
+    return null;
+  }
+
   // ── Messages ──────────────────────────────────────────────────
 
   private async sendMessage(
@@ -752,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);
@@ -811,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,
@@ -831,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 {
@@ -855,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 };
   }
@@ -984,6 +1068,13 @@ export class AgentBridge {
     return { commands: entry.agent.getSlashCommands() };
   }
 
+  private getSubagentConfigurations(sessionId?: string): {
+    configurations: SubagentConfiguration[];
+  } {
+    const entry = this.requireSession(sessionId);
+    return { configurations: entry.agent.getSubagentConfigurations() };
+  }
+
   // ── File / History (global) ───────────────────────────────────
 
   private async searchFiles(
@@ -1099,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<{
@@ -1107,13 +1218,6 @@ export class AgentBridge {
     serverUrl: string;
   }> {
     const authService = AuthService.getInstance();
-    // A stale-but-refreshable token still means "logged in" — the daemon may
-    // have started with an expired access token (hourly expiry) and only
-    // refreshes lazily on the first API call. Without this proactive refresh a
-    // fresh client querying right after daemon start gets a false
-    // isAuthenticated and e.g. the desktop welcome page keeps showing the
-    // login button for an authenticated host. Mirrors the refresh that
-    // createAuthAwareFetch does before every real request.
     await authService.checkAndRefreshTokenIfNeeded();
     return {
       isAuthenticated: authService.isSSOAuthenticated(),
@@ -1424,10 +1528,10 @@ export class AgentBridge {
           ctx.registeredSessionId,
         );
       },
-      onCompleteBangMessage: (command, exitCode, messageId) => {
+      onCompleteBangMessage: (command, exitCode, messageId, output) => {
         this.emit(
           "bangMessageCompleted",
-          { command, exitCode, messageId },
+          { command, exitCode, messageId, output },
           ctx.registeredSessionId,
         );
       },

package/src/stdio/protocol.ts

@@ -75,8 +75,12 @@ export type RequestMethod =
   | "getPromptHistory"
   | "searchPromptHistory"
   | "updateConfig"
+  | "getConfiguredModels"
+  | "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"

package/src/utils/usageSummary.ts

@@ -12,13 +12,9 @@ export interface TokenSummary {
     agent_calls: number;
     compactions: number;
   };
-  // Cache-related tokens (for Claude models)
+  // Normalized cache tokens
   cache_read_input_tokens?: number;
   cache_creation_input_tokens?: number;
-  cache_creation?: {
-    ephemeral_5m_input_tokens: number;
-    ephemeral_1h_input_tokens: number;
-  };
 }
 
 /**
@@ -65,22 +61,6 @@ export function calculateTokenSummary(
         (summary.cache_creation_input_tokens || 0) +
         usage.cache_creation_input_tokens;
     }
-    if (
-      usage.cache_creation &&
-      (usage.cache_creation.ephemeral_5m_input_tokens > 0 ||
-        usage.cache_creation.ephemeral_1h_input_tokens > 0)
-    ) {
-      if (!summary.cache_creation) {
-        summary.cache_creation = {
-          ephemeral_5m_input_tokens: 0,
-          ephemeral_1h_input_tokens: 0,
-        };
-      }
-      summary.cache_creation.ephemeral_5m_input_tokens +=
-        usage.cache_creation.ephemeral_5m_input_tokens || 0;
-      summary.cache_creation.ephemeral_1h_input_tokens +=
-        usage.cache_creation.ephemeral_1h_input_tokens || 0;
-    }
 
     // Track operation types
     if (usage.operation_type === "agent") {
@@ -132,8 +112,6 @@ export function displayUsageSummary(
   let totalCompactions = 0;
   let totalCacheRead = 0;
   let totalCacheCreation = 0;
-  let totalCache5m = 0;
-  let totalCache1h = 0;
   let hasCacheData = false;
 
   for (const [, summary] of Object.entries(summaries)) {
@@ -147,8 +125,7 @@ export function displayUsageSummary(
     // Display cache information if available
     if (
       summary.cache_read_input_tokens ||
-      summary.cache_creation_input_tokens ||
-      summary.cache_creation
+      summary.cache_creation_input_tokens
     ) {
       hasCacheData = true;
       console.log("  Cache Usage:");
@@ -172,21 +149,6 @@ export function displayUsageSummary(
         );
         totalCacheCreation += summary.cache_creation_input_tokens;
       }
-
-      if (summary.cache_creation) {
-        if (summary.cache_creation.ephemeral_5m_input_tokens > 0) {
-          console.log(
-            `    5m cache: ${summary.cache_creation.ephemeral_5m_input_tokens.toLocaleString()} tokens`,
-          );
-          totalCache5m += summary.cache_creation.ephemeral_5m_input_tokens;
-        }
-        if (summary.cache_creation.ephemeral_1h_input_tokens > 0) {
-          console.log(
-            `    1h cache: ${summary.cache_creation.ephemeral_1h_input_tokens.toLocaleString()} tokens`,
-          );
-          totalCache1h += summary.cache_creation.ephemeral_1h_input_tokens;
-        }
-      }
     }
 
     console.log(
@@ -219,12 +181,6 @@ export function displayUsageSummary(
           `    Created cache: ${totalCacheCreation.toLocaleString()} tokens`,
         );
       }
-      if (totalCache5m > 0) {
-        console.log(`    5m cache: ${totalCache5m.toLocaleString()} tokens`);
-      }
-      if (totalCache1h > 0) {
-        console.log(`    1h cache: ${totalCache1h.toLocaleString()} tokens`);
-      }
     }
 
     console.log(