wave-code 1.0.7 → 1.0.8

package/src/contexts/useChat.tsx

@@ -31,7 +31,6 @@ import {
   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";
 
@@ -112,6 +111,7 @@ export interface ChatContextType {
     hidePersistentOption?: boolean;
     planContent?: string;
     permissionMode?: PermissionMode;
+    warning?: string;
   };
   showConfirmation: (
     toolName: string,
@@ -120,6 +120,7 @@ export interface ChatContextType {
     hidePersistentOption?: boolean,
     planContent?: string,
     permissionMode?: PermissionMode,
+    warning?: string,
   ) => Promise<PermissionDecision>;
   hideConfirmation: () => void;
   handleConfirmationDecision: (decision: PermissionDecision) => void;
@@ -239,6 +240,99 @@ function createStreamingWindowThrottle(
   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: (params: ToolBlockUpdateCallbackParams) => void,
+  wait: number,
+): {
+  (params: ToolBlockUpdateCallbackParams): void;
+  cancel: () => void;
+  flush: () => void;
+} {
+  let timer: NodeJS.Timeout | null = null;
+  let pending: { messageId: string; chunks: Map<string, string> } | null = 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: ToolBlockUpdateCallbackParams) => {
+    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: React.FC<ChatProviderProps> = ({
   children,
   bypassPermissions,
@@ -345,8 +439,13 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
 
   const throttledToolBlockUpdate = useMemo(
     () =>
-      throttle((params: ToolBlockUpdateCallbackParams) => {
-        const { messageId, id: toolBlockId, ...updates } = params;
+      createToolStreamingThrottle((params) => {
+        const {
+          messageId,
+          id: toolBlockId,
+          parametersChunk,
+          ...updates
+        } = params;
         setMessages((prev) =>
           prev.map((m) => {
             if (m.id !== messageId) return m;
@@ -363,7 +462,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
                     id: toolBlockId,
                     name: updates.name || "",
                     stage: updates.stage || "start",
-                    parameters: updates.parameters || "",
+                    parameters:
+                      (updates.parameters || "") + (parametersChunk || ""),
                     result: updates.result || "",
                     ...updates,
                   },
@@ -374,7 +474,18 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
               ...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,
               ),
             };
@@ -443,6 +554,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         hidePersistentOption?: boolean;
         planContent?: string;
         permissionMode?: PermissionMode;
+        warning?: string;
       }
     | undefined
   >();
@@ -454,6 +566,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       hidePersistentOption?: boolean;
       planContent?: string;
       permissionMode?: PermissionMode;
+      warning?: string;
       resolver: (decision: PermissionDecision) => void;
       reject: () => void;
     }>
@@ -465,6 +578,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     hidePersistentOption?: boolean;
     planContent?: string;
     permissionMode?: PermissionMode;
+    warning?: string;
     resolver: (decision: PermissionDecision) => void;
     reject: () => void;
   } | null>(null);
@@ -506,6 +620,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       hidePersistentOption?: boolean,
       planContent?: string,
       permissionMode?: PermissionMode,
+      warning?: string,
     ): Promise<PermissionDecision> => {
       return new Promise<PermissionDecision>((resolve, reject) => {
         const queueItem = {
@@ -515,6 +630,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
           hidePersistentOption,
           planContent,
           permissionMode,
+          warning,
           resolver: resolve,
           reject,
         };
@@ -723,6 +839,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
               context.hidePersistentOption,
               context.planContent,
               context.permissionMode,
+              context.warning,
             );
           } catch {
             // If confirmation was cancelled or failed, deny the operation
@@ -1070,6 +1187,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         hidePersistentOption: next.hidePersistentOption,
         planContent: next.planContent,
         permissionMode: next.permissionMode,
+        warning: next.warning,
       });
       setIsConfirmationVisible(true);
       setConfirmationQueue((prev) => prev.slice(1));

package/src/daemon/commands.ts

@@ -0,0 +1,444 @@
+/**
+ * `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,
+  type Message,
+  type PermissionDecision,
+  type PermissionMode,
+  type ToolPermissionContext,
+} 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: PermissionMode[] = [
+  "default",
+  "bypassPermissions",
+  "acceptEdits",
+  "plan",
+  "dontAsk",
+];
+
+// ── Connection helpers ─────────────────────────────────────────
+
+function connectDaemon(socketPath: string): Promise<SocketClient> {
+  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: string): Promise<SocketClient> {
+  try {
+    return await connectDaemon(socketPath);
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    console.error(
+      `无法连接 daemon socket ${socketPath}：daemon 未运行？（daemon 空闲 60 秒自动退出）` +
+        (code ? ` (${code})` : ""),
+    );
+    process.exit(1);
+  }
+}
+
+function fail(message: string): never {
+  console.error(message);
+  process.exit(1);
+}
+
+interface DaemonSessionEntry {
+  sessionId: string;
+  workingDirectory: string;
+  isLoading: boolean;
+  messageCount: number;
+}
+
+interface PendingPermission {
+  requestId: string;
+  sessionId?: string;
+  context: ToolPermissionContext;
+}
+
+/**
+ * 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: SocketClient,
+  sessionId: string,
+): Promise<{ sessionId: string; workingDirectory: string }> {
+  const init = (await client.request("initialize", {
+    workdir: process.cwd(),
+    restoreSessionId: sessionId,
+  })) as { sessionId: string; workingDirectory: string };
+  const initId = init.sessionId;
+  try {
+    await client.request("restoreSession", { sessionId }, initId);
+  } catch (err) {
+    if ((err as Error).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: SocketClient,
+): Promise<PendingPermission[]> {
+  const result = (await client.request("listPendingPermissions")) as {
+    requests: PendingPermission[];
+  };
+  return result.requests ?? [];
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// ── list ───────────────────────────────────────────────────────
+
+export async function daemonListCommand(socketPath: string): Promise<void> {
+  let client: SocketClient | undefined;
+  try {
+    client = await connectDaemonOrExit(socketPath);
+    const result = (await client.request("listDaemonSessions")) as {
+      sessions: DaemonSessionEntry[];
+    };
+    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: keyof (typeof rows)[number]) =>
+        Math.max(...rows.map((r) => r[key].length), key.length);
+      const pad = (value: string, w: number) => 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 as Error).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: ToolPermissionContext): string {
+  const input = context.toolInput;
+  if (!input || Object.keys(input).length === 0) return "";
+  let text: string;
+  try {
+    text = JSON.stringify(input);
+  } catch {
+    text = "";
+  }
+  return text.length > 80 ? `${text.slice(0, 80)}…` : text;
+}
+
+export async function daemonStatusCommand(
+  socketPath: string,
+  sessionId: string,
+  lines = 20,
+): Promise<void> {
+  let client: SocketClient | undefined;
+  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 as { loading: boolean }).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,
+    )) as {
+      messages: Message[];
+    };
+
+    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 as Error).message}`);
+  } finally {
+    await client?.dispose();
+  }
+  process.exit(0);
+}
+
+// ── send ───────────────────────────────────────────────────────
+
+export interface SendOptions {
+  timeout: number; // seconds; 0 = no limit (default 600)
+}
+
+/**
+ * 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: string,
+  sessionId: string,
+  message: string,
+  options: SendOptions = { timeout: 600 },
+): Promise<void> {
+  // connectDaemonOrExit exits on failure — no client to dispose in that case.
+  const client = await connectDaemonOrExit(socketPath);
+
+  let loading = false;
+  let sent = false;
+  let ourUserMessageId: string | undefined;
+  let replyMessageId: string | undefined;
+  client.onNotification("userMessageAdded", (params) => {
+    if (!sent) return; // ignore messages added during attach
+    ourUserMessageId = (params as { message: Message }).message.id;
+  });
+  client.onNotification("assistantMessageAdded", (params) => {
+    if (!sent || ourUserMessageId === undefined) return; // not our turn yet
+    replyMessageId = (params as { message: Message }).message.id;
+  });
+  client.onNotification("loadingChange", (params) => {
+    loading = (params as { loading: boolean }).loading;
+  });
+
+  let initId: string;
+  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 as Error).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)) as {
+      messages: Message[];
+    };
+    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 as Error).message}`);
+  } finally {
+    client.dispose();
+  }
+  process.exit(0);
+}
+
+// ── respond ────────────────────────────────────────────────────
+
+export interface RespondOptions {
+  allow?: boolean;
+  deny?: boolean;
+  reason?: string;
+  answer?: string;
+  rule?: string;
+  mode?: string;
+}
+
+export async function daemonRespondCommand(
+  socketPath: string,
+  sessionId: string,
+  requestId: string,
+  options: RespondOptions,
+): Promise<void> {
+  if (!!options.allow === !!options.deny) {
+    fail("请指定 --allow 或 --deny（二选一）");
+  }
+  let client: SocketClient | undefined;
+  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: PermissionDecision;
+    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: unknown;
+        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 as PermissionMode)) {
+          fail(
+            `无效的权限模式：${options.mode}（可选：${PERMISSION_MODES.join("、")}）`,
+          );
+        }
+        decision.newPermissionMode = options.mode as PermissionMode;
+      }
+    }
+
+    // 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 as Error).message}`);
+  } finally {
+    await client?.dispose();
+  }
+  process.exit(0);
+}