wave-code 0.19.9 → 1.0.1

package/src/print-cli.ts

@@ -4,6 +4,7 @@ import {
   hasUncommittedChanges,
   hasNewCommits,
   getDefaultRemoteBranch,
+  validateWorktreeRemovalPath,
   type WorktreeSession,
 } from "wave-agent-sdk";
 import { displayUsageSummary } from "./utils/usageSummary.js";
@@ -183,18 +184,18 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
     // Display timing information
     displayTimingInfo(startTime, showStats);
 
-    // Destroy agent and exit after sendMessage completes
-    await agent.destroy();
-
-    // Handle worktree cleanup for print mode
+    // Trigger WorktreeRemove hook (before destroy — it needs a live agent) and
+    // decide whether the worktree is clean enough to remove
+    let cleanWorktree = false;
     if (worktreeSession) {
       const cwd = workdir || worktreeSession.path;
       const baseBranch = getDefaultRemoteBranch(cwd);
       const hasChanges = hasUncommittedChanges(cwd);
       const hasCommits = hasNewCommits(cwd, baseBranch);
+      cleanWorktree = !hasChanges && !hasCommits;
 
-      if (!hasChanges && !hasCommits) {
-        await removeWorktree(worktreeSession);
+      if (cleanWorktree) {
+        await agent.triggerWorktreeRemoveHook(worktreeSession.path);
       } else {
         process.stdout.write(
           `\n⚠️ Worktree '${worktreeSession.name}' has changes or commits. Keeping it at: ${worktreeSession.path}\n`,
@@ -202,6 +203,25 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       }
     }
 
+    // Destroy agent and exit after sendMessage completes
+    await agent.destroy();
+
+    // Handle worktree cleanup for print mode (git removal stays after destroy)
+    if (worktreeSession && cleanWorktree) {
+      try {
+        validateWorktreeRemovalPath(
+          worktreeSession.path,
+          worktreeSession.repoRoot,
+        );
+        await removeWorktree(worktreeSession);
+      } catch (error) {
+        // Never block print-mode exit on worktree cleanup failures
+        process.stdout.write(
+          `\n⚠️ Skipping worktree removal: ${(error as Error).message}\n`,
+        );
+      }
+    }
+
     process.exit(0);
   } catch (error) {
     console.error("Failed to send message:", error);
@@ -220,23 +240,40 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       // Display timing information even on error
       displayTimingInfo(startTime, showStats);
 
-      await agent.destroy();
-
-      // Handle worktree cleanup for print mode even on error
+      // Trigger WorktreeRemove hook (before destroy) when the worktree is clean
+      let cleanWorktree = false;
       if (worktreeSession) {
         const cwd = workdir || worktreeSession.path;
         const baseBranch = getDefaultRemoteBranch(cwd);
         const hasChanges = hasUncommittedChanges(cwd);
         const hasCommits = hasNewCommits(cwd, baseBranch);
+        cleanWorktree = !hasChanges && !hasCommits;
 
-        if (!hasChanges && !hasCommits) {
-          await removeWorktree(worktreeSession);
+        if (cleanWorktree) {
+          await agent.triggerWorktreeRemoveHook(worktreeSession.path);
         } else {
           process.stdout.write(
             `\n⚠️ Worktree '${worktreeSession.name}' has changes or commits. Keeping it at: ${worktreeSession.path}\n`,
           );
         }
       }
+
+      await agent.destroy();
+
+      // Handle worktree cleanup for print mode even on error
+      if (worktreeSession && cleanWorktree) {
+        try {
+          validateWorktreeRemovalPath(
+            worktreeSession.path,
+            worktreeSession.repoRoot,
+          );
+          await removeWorktree(worktreeSession);
+        } catch (error) {
+          process.stdout.write(
+            `\n⚠️ Skipping worktree removal: ${(error as Error).message}\n`,
+          );
+        }
+      }
     }
     process.exit(1);
   }

package/src/stdio/agentBridge.ts

@@ -40,6 +40,7 @@ import {
   PromptHistoryManager,
   AuthService,
   PluginCore,
+  validateWorktreeRemovalPath,
   type SlashCommand,
 } from "wave-agent-sdk";
 import {
@@ -50,6 +51,7 @@ import {
 import { execFileSync } from "node:child_process";
 import { createWorktree, removeWorktree } from "../utils/worktree.js";
 import { logger } from "../utils/logger.js";
+import { isUserCheckpointMessage } from "../utils/rewindCheckpoints.js";
 
 export type NotificationEmitter = (
   method: string,
@@ -116,9 +118,16 @@ interface SessionContext {
 
 export class AgentBridge {
   private sessions = new Map<string, SessionEntry>();
+  /** Pending approval requests, keyed by requestId. Stored with the resolve +
+   * context so a re-attached client can list and respond to them (daemon mode:
+   * approvals outlive any single connection). */
   private pendingPermissions = new Map<
     string,
-    (decision: PermissionDecision) => void
+    {
+      resolve: (decision: PermissionDecision) => void;
+      sessionId?: string;
+      context: ToolPermissionContext;
+    }
   >();
   private permissionCounter = 0;
   private emit: NotificationEmitter;
@@ -149,6 +158,8 @@ export class AgentBridge {
         return this.listSessions(p.workdir as string | undefined, sessionId);
       case "getSessionInfo":
         return this.getSessionInfo(sessionId);
+      case "listPendingPermissions":
+        return this.listPendingPermissions();
       case "updateConfig":
         return this.updateConfig(p as unknown as UpdateConfigParams, sessionId);
 
@@ -164,6 +175,8 @@ export class AgentBridge {
         );
       case "bang":
         return this.bang(p.command as string, sessionId);
+      case "askBtw":
+        return this.askBtw(p.question as string, sessionId);
       case "abortMessage":
         return this.abortMessage(sessionId);
       case "clearMessages":
@@ -351,10 +364,10 @@ export class AgentBridge {
         decision: PermissionDecision;
       };
       // requestId is process-level unique; lookup doesn't need sessionId
-      const resolve = this.pendingPermissions.get(p.requestId);
-      if (resolve) {
+      const entry = this.pendingPermissions.get(p.requestId);
+      if (entry) {
         this.pendingPermissions.delete(p.requestId);
-        resolve(p.decision);
+        entry.resolve(p.decision);
       }
     }
   }
@@ -367,6 +380,21 @@ export class AgentBridge {
     permissionMode: PermissionMode;
     latestTotalTokens: number;
   }> {
+    // Re-attach (daemon mode): if the target session is already live in this
+    // process, reuse it instead of creating a second agent writing to the same
+    // transcript. The live agent keeps running across client detach/attach.
+    if (params.restoreSessionId) {
+      const live = this.sessions.get(params.restoreSessionId);
+      if (live) {
+        return {
+          sessionId: live.agent.sessionId,
+          workingDirectory: live.agent.workingDirectory,
+          permissionMode: live.agent.getPermissionMode(),
+          latestTotalTokens: live.agent.latestTotalTokens,
+        };
+      }
+    }
+
     const ctx: SessionContext = {};
     const callbacks = this.createCallbacks(ctx);
 
@@ -421,11 +449,70 @@ export class AgentBridge {
     return null;
   }
 
+  /**
+   * True when every hosted session has settled: not generating, nothing queued,
+   * and no background work (background bash / subagents / workflows) — the same
+   * condition `wave -p` waits on before exiting (print-cli.ts). Pending
+   * permission approvals keep the owning agent's isLoading true, so they are
+   * covered without an explicit check.
+   */
+  public isIdle(): boolean {
+    for (const entry of this.sessions.values()) {
+      const agent = entry.agent;
+      if (
+        agent.isLoading ||
+        agent.hasPendingMessages ||
+        agent.hasRunningBackgroundWork
+      ) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Destroy every hosted session agent. Each Agent.destroy() saves its
+   * transcript, drains in-flight auto-memory extraction, and cleans up
+   * background tasks/subagents. Best-effort: one failing destroy must not
+   * block the rest of the shutdown.
+   */
+  public async destroyAll(): Promise<void> {
+    const entries = [...this.sessions.values()];
+    this.sessions.clear();
+    await Promise.all(
+      entries.map((entry) => entry.agent.destroy().catch(() => {})),
+    );
+  }
+
   private async restoreSession(
     restoreId: string,
     sessionId?: string,
   ): Promise<null> {
     const entry = this.requireSession(sessionId);
+    // Re-attach to a live session: the SDK restore would no-op (target is
+    // already current). Emit the current messages so the freshly attached
+    // client — whose router registered only after initialize returned and so
+    // missed any earlier notifications — gets a snapshot without replay.
+    if (entry.agent.sessionId === restoreId) {
+      this.emit(
+        "messagesChange",
+        { messages: entry.agent.messages },
+        entry.agent.sessionId,
+      );
+      // The re-attached client also missed the loading state that settled
+      // before its router registered — replay it or the client's
+      // isStreaming/running indicator stays false while the live session
+      // keeps generating.
+      this.emit(
+        "loadingChange",
+        {
+          loading: entry.agent.isLoading,
+          latestTotalTokens: entry.agent.latestTotalTokens,
+        },
+        entry.agent.sessionId,
+      );
+      return null;
+    }
     await entry.agent.restoreSession(restoreId);
     return null;
   }
@@ -526,6 +613,28 @@ export class AgentBridge {
     branch: string;
     repoRoot: string;
   }): Promise<{ ok: true }> {
+    // Align with Claude Code v2.1.216+: refuse to remove a worktree whose path
+    // is a symlink or resolves outside the repo root. Already-removed (missing)
+    // paths pass validation so removal stays idempotent.
+    try {
+      validateWorktreeRemovalPath(params.path, params.repoRoot);
+    } catch (e) {
+      throw new RpcError(PROTOCOL_INTERNAL_ERROR, (e as Error).message);
+    }
+
+    // Trigger the WorktreeRemove hook (before git removal, non-blocking) using
+    // the session that runs in this worktree, if it is still registered.
+    for (const entry of this.sessions.values()) {
+      if (entry.agent.workingDirectory === params.path) {
+        try {
+          await entry.agent.triggerWorktreeRemoveHook(params.path);
+        } catch (e) {
+          logger.warn("WorktreeRemove hooks execution failed:", e);
+        }
+        break;
+      }
+    }
+
     // removeWorktree is best-effort/idempotent: already-removed worktrees or
     // branches only log, never throw.
     await removeWorktree({
@@ -643,6 +752,35 @@ export class AgentBridge {
     return null;
   }
 
+  private async askBtw(question: string, sessionId?: string): Promise<string> {
+    const entry = this.requireSession(sessionId);
+    return entry.agent.askBtw(
+      question,
+      undefined,
+      // Stream partial content to the client so webview hosts can render the
+      // answer incrementally (thinking and content travel on separate
+      // channels so the panel can drop thinking text once content starts).
+      (content) => {
+        if (sessionId) {
+          this.emit(
+            "btwContent",
+            { question, content, type: "content" },
+            sessionId,
+          );
+        }
+      },
+      (content) => {
+        if (sessionId) {
+          this.emit(
+            "btwContent",
+            { question, content, type: "thinking" },
+            sessionId,
+          );
+        }
+      },
+    );
+  }
+
   private async abortMessage(sessionId?: string): Promise<null> {
     const entry = this.requireSession(sessionId);
     entry.agent.abortMessage();
@@ -684,7 +822,7 @@ export class AgentBridge {
     const entry = this.requireSession(sessionId);
     const { messages } = await entry.agent.getFullMessageThread();
     const checkpoints = messages
-      .filter((m) => m.role === "user" && !m.isMeta && m.id)
+      .filter((m) => isUserCheckpointMessage(m) && m.id)
       .map((m) => ({
         id: m.id as string,
         content: getMessageContent(m).replace(/\s+/g, " ").trim(),
@@ -877,7 +1015,11 @@ export class AgentBridge {
   ): Promise<PermissionDecision> {
     const requestId = `perm_${++this.permissionCounter}`;
     return new Promise<PermissionDecision>((resolve) => {
-      this.pendingPermissions.set(requestId, resolve);
+      this.pendingPermissions.set(requestId, {
+        resolve,
+        sessionId: ctx.registeredSessionId,
+        context,
+      });
       this.emit(
         "permissionRequest",
         { requestId, context },
@@ -886,6 +1028,27 @@ export class AgentBridge {
     });
   }
 
+  /** Attach snapshot: re-surface approvals that are still pending after a
+   * client disconnected (daemon mode). Responding to any listed requestId
+   * resolves the in-process promise. */
+  private listPendingPermissions(): {
+    requests: Array<{
+      requestId: string;
+      sessionId?: string;
+      context: ToolPermissionContext;
+    }>;
+  } {
+    return {
+      requests: [...this.pendingPermissions.entries()].map(
+        ([requestId, entry]) => ({
+          requestId,
+          sessionId: entry.sessionId,
+          context: entry.context,
+        }),
+      ),
+    };
+  }
+
   // ── Auth (global) ────────────────────────────────────────────
 
   private async getAuthStatus(): Promise<{
@@ -1067,9 +1230,6 @@ export class AgentBridge {
 
   private createCallbacks(ctx: SessionContext): AgentCallbacks {
     return {
-      onMessagesChange: (messages: Message[]) => {
-        this.emit("messagesChange", { messages }, ctx.registeredSessionId);
-      },
       onUserMessageAdded: () => {
         const msg = this.findLastUserMessage(ctx.agent);
         if (msg)
@@ -1089,13 +1249,36 @@ export class AgentBridge {
           );
       },
       onAssistantContentUpdated: (params) => {
-        this.emit("assistantContentUpdated", params, ctx.registeredSessionId);
+        // Wire carries only the delta; consumers accumulate (spec: 流式通知纯增量负载).
+        this.emit(
+          "assistantContentUpdated",
+          {
+            messageId: params.messageId,
+            chunk: params.chunk,
+            stage: params.stage,
+          },
+          ctx.registeredSessionId,
+        );
       },
       onAssistantReasoningUpdated: (params) => {
-        this.emit("assistantReasoningUpdated", params, ctx.registeredSessionId);
+        this.emit(
+          "assistantReasoningUpdated",
+          {
+            messageId: params.messageId,
+            chunk: params.chunk,
+            stage: params.stage,
+          },
+          ctx.registeredSessionId,
+        );
       },
       onToolBlockUpdated: (params) => {
-        this.emit("toolBlockUpdated", params, ctx.registeredSessionId);
+        // Streaming stages carry only the parametersChunk delta; start/running
+        // (one-time snapshots) and end (authoritative full value) keep
+        // `parameters` (spec: 流式通知纯增量负载).
+        const { parameters, ...rest } = params;
+        void parameters;
+        const wireParams = params.stage === "streaming" ? rest : params;
+        this.emit("toolBlockUpdated", wireParams, ctx.registeredSessionId);
       },
       onErrorBlockAdded: (error: string) => {
         this.emit("errorBlockAdded", { error }, ctx.registeredSessionId);
@@ -1169,14 +1352,26 @@ export class AgentBridge {
       onMcpServersChange: (servers: McpServerStatus[]) => {
         this.emit("mcpServersChange", { servers }, ctx.registeredSessionId);
       },
-      onAddBangMessage: () => {
-        this.emit("bangMessageAdded", {}, ctx.registeredSessionId);
+      onAddBangMessage: (command, messageId) => {
+        this.emit(
+          "bangMessageAdded",
+          { command, messageId },
+          ctx.registeredSessionId,
+        );
       },
-      onUpdateBangMessage: () => {
-        this.emit("bangMessageUpdated", {}, ctx.registeredSessionId);
+      onUpdateBangMessage: (command, output, messageId) => {
+        this.emit(
+          "bangMessageUpdated",
+          { command, output, messageId },
+          ctx.registeredSessionId,
+        );
       },
-      onCompleteBangMessage: () => {
-        this.emit("bangMessageCompleted", {}, ctx.registeredSessionId);
+      onCompleteBangMessage: (command, exitCode, messageId) => {
+        this.emit(
+          "bangMessageCompleted",
+          { command, exitCode, messageId },
+          ctx.registeredSessionId,
+        );
       },
       onNotificationMessageAdded: (params) => {
         const msg = ctx.agent?.messages.find(

package/src/stdio/daemonServer.ts

@@ -0,0 +1,212 @@
+/**
+ * DaemonServer — JSON-RPC server over a unix socket for remote background
+ * sessions (spec: docs/specs/ui/desktop-app.md 「SSH 远程后台会话」).
+ *
+ * The desktop app launches `wave --daemon <socket>` on the remote host via
+ * nohup/setsid, then tunnels the socket back with `ssh -L`. All connections
+ * share one AgentBridge, so sessions and pending tool permissions survive
+ * client detach/attach — the daemon keeps running (and generating) while no
+ * desktop is connected. The daemon never exits on a client disconnect; it
+ * only exits when killed (app quit / 删除会话 / remote reboot).
+ *
+ * Idle auto-exit (spec: 「远程 daemon 空闲自动退出」): once every session has
+ * settled and no client is connected, the daemon mirrors `wave -p`'s exit
+ * semantics — after a grace period it destroys the sessions (saving their
+ * transcripts), closes the socket, and exits, so the remote process doesn't
+ * linger forever after background work completes.
+ */
+
+import net from "net";
+import * as fs from "fs";
+import { AgentBridge, type AgentBridgeOptions } from "./agentBridge.js";
+import { JsonRpcConnection } from "./jsonRpcConnection.js";
+
+export interface DaemonServerOptions {
+  socketPath: string;
+  bridgeOptions?: AgentBridgeOptions;
+  /** Idle grace period before the daemon auto-exits (default 60s). */
+  graceMs?: number;
+}
+
+export class DaemonServer {
+  static readonly DEFAULT_IDLE_GRACE_MS = 60_000;
+
+  private socketPath: string;
+  private server: net.Server | undefined;
+  private bridge: AgentBridge;
+  private connections = new Set<JsonRpcConnection>();
+  private sockets = new Set<net.Socket>();
+  private graceMs: number;
+  private idleTimer: NodeJS.Timeout | undefined;
+  private shuttingDown = false;
+  private stopped = false;
+
+  constructor(options: DaemonServerOptions) {
+    this.socketPath = options.socketPath;
+    this.graceMs = options.graceMs ?? DaemonServer.DEFAULT_IDLE_GRACE_MS;
+    this.bridge = new AgentBridge({
+      ...options.bridgeOptions,
+      // Notifications go to every attached client; a fully detached daemon
+      // has none, and the write is dropped silently (the attach snapshot
+      // re-syncs state on reconnect).
+      emit: (method, params, sessionId) => {
+        for (const conn of this.connections) {
+          conn.sendNotification(method, params, sessionId);
+        }
+        // Any session activity can change the idle state — re-evaluate.
+        this.evaluateIdle();
+      },
+    });
+    this.server = net.createServer((socket) => {
+      if (this.shuttingDown) {
+        socket.destroy();
+        return;
+      }
+      const conn = new JsonRpcConnection(socket, socket, this.bridge);
+      this.connections.add(conn);
+      this.sockets.add(socket);
+      // A (re)attached client cancels a pending idle exit.
+      this.evaluateIdle();
+      socket.on("error", () => {
+        // The client (ssh tunnel) can reset the socket mid-detach; the daemon
+        // must keep running — 'close' below cleans up the connection.
+      });
+      socket.on("close", () => {
+        this.connections.delete(conn);
+        this.sockets.delete(socket);
+        // A client detach may leave the daemon idle — re-evaluate.
+        this.evaluateIdle();
+      });
+      conn.start();
+    });
+  }
+
+  get agentBridge(): AgentBridge {
+    return this.bridge;
+  }
+
+  /**
+   * Listen on the socket path. Rejects when a live daemon already holds it. A
+   * stale socket file left by a crashed daemon would otherwise block the
+   * restart with EADDRINUSE, so it is cleaned up first: non-socket files are
+   * unlinked outright; socket files are probe-connected — ECONNREFUSED means
+   * no listener (stale → unlink and listen), anything else means a live
+   * daemon owns the path (reject).
+   */
+  start(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const server = this.server;
+      if (!server) return resolve();
+      try {
+        const st = fs.statSync(this.socketPath);
+        if (st.isSocket()) {
+          const probe = net.connect(this.socketPath);
+          probe.once("connect", () => {
+            probe.destroy();
+            reject(
+              new Error(`另一个 wave daemon 已在 ${this.socketPath} 监听`),
+            );
+          });
+          probe.once("error", (err: NodeJS.ErrnoException) => {
+            probe.destroy();
+            if (err.code === "ECONNREFUSED") {
+              fs.unlinkSync(this.socketPath);
+              this.listen(server, resolve, reject);
+            } else {
+              reject(err);
+            }
+          });
+          return;
+        }
+        fs.unlinkSync(this.socketPath);
+      } catch {
+        // ENOENT — no stale socket, listen directly.
+      }
+      this.listen(server, resolve, reject);
+    });
+  }
+
+  private listen(
+    server: net.Server,
+    resolve: () => void,
+    reject: (err: Error) => void,
+  ): void {
+    server.once("error", reject);
+    server.listen(this.socketPath, () => {
+      server.removeListener("error", reject);
+      resolve();
+      // A freshly started daemon may already be idle (no sessions) — start the
+      // idle watch so a zero-session daemon also auto-exits.
+      this.evaluateIdle();
+    });
+  }
+
+  stop(): Promise<void> {
+    this.stopped = true;
+    this.clearIdleTimer();
+    return new Promise((resolve) => {
+      const server = this.server;
+      if (!server) return resolve();
+      this.server = undefined;
+      server.close(() => resolve());
+    });
+  }
+
+  // ── Idle auto-exit ────────────────────────────────────────────
+
+  private clearIdleTimer(): void {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = undefined;
+    }
+  }
+
+  /**
+   * Re-evaluate the idle condition after any state transition: sessions busy
+   * (loading / pending messages / background work) or any client attached →
+   * cancel the timer. Fully idle + detached → arm the grace timer once; when
+   * it fires, shut the daemon down. Evaluation is event-driven (every
+   * busy→idle transition emits a notification, every attach/detach fires a
+   * connection event), so nothing is polled. The failure mode is
+   * conservative: a missed transition just leaves the daemon running.
+   */
+  private evaluateIdle(): void {
+    // A stopped/shutting-down daemon never (re)arms the idle timer — late
+    // socket 'close' events (which fire after server.close resolves) must not
+    // resurrect a timer after stop().
+    if (this.shuttingDown || this.stopped) return;
+    if (this.connections.size > 0 || !this.bridge.isIdle()) {
+      this.clearIdleTimer();
+      return;
+    }
+    if (this.idleTimer) return;
+    this.idleTimer = setTimeout(() => {
+      this.idleTimer = undefined;
+      void this.shutdown();
+    }, this.graceMs);
+  }
+
+  /**
+   * Destroy the sessions (each agent saves its transcript and drains
+   * auto-memory), close the listener, unlink the socket file, then exit.
+   * `shuttingDown` guards against re-entry: new connections are refused and
+   * further idle evaluations become no-ops.
+   */
+  private async shutdown(): Promise<void> {
+    if (this.shuttingDown) return;
+    this.shuttingDown = true;
+    this.clearIdleTimer();
+    // Destroy client sockets first so server.close() can complete (an open
+    // socket keeps the close callback pending).
+    for (const socket of this.sockets) socket.destroy();
+    this.sockets.clear();
+    await this.bridge.destroyAll();
+    await this.stop();
+    try {
+      fs.unlinkSync(this.socketPath);
+    } catch {
+      // Already gone — a stale file would be probed/unlinked on next start.
+    }
+    process.exit(0);
+  }
+}

package/src/stdio/index.ts

@@ -1,4 +1,6 @@
 export { StdioServer, type StdioServerOptions } from "./stdioServer.js";
+export { JsonRpcConnection } from "./jsonRpcConnection.js";
+export { DaemonServer, type DaemonServerOptions } from "./daemonServer.js";
 export {
   AgentBridge,
   type AgentBridgeOptions,