wave-code 1.0.6 → 1.0.8

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);
+}

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/hooks/useInputManager.ts

@@ -242,6 +242,8 @@ export const useInputManager = (
                 });
               } 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") {
@@ -493,6 +495,10 @@ export const useInputManager = (
     dispatch({ type: "SET_SHOW_MCP_MANAGER", payload: show });
   }, []);
 
+  const setShowAgentsManager = useCallback((show: boolean) => {
+    dispatch({ type: "SET_SHOW_AGENTS_MANAGER", payload: show });
+  }, []);
+
   const setShowRewindManager = useCallback((show: boolean) => {
     dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: show });
   }, []);
@@ -657,6 +663,7 @@ export const useInputManager = (
     historySearchQuery: state.historySearchQuery,
     showBackgroundTaskManager: state.showBackgroundTaskManager,
     showMcpManager: state.showMcpManager,
+    showAgentsManager: state.showAgentsManager,
     showRewindManager: state.showRewindManager,
     showHelp: state.showHelp,
     showStatusCommand: state.showStatusCommand,
@@ -702,6 +709,7 @@ export const useInputManager = (
     // Bash/MCP Manager
     setShowBackgroundTaskManager,
     setShowMcpManager,
+    setShowAgentsManager,
     setShowRewindManager,
     setShowHelp,
     setShowStatusCommand,