wave-code 1.1.4 → 1.2.0

package/src/stdio/daemonServer.ts

@@ -1,19 +1,17 @@
 /**
  * DaemonServer — JSON-RPC server over a unix socket for remote background
- * sessions (spec: docs/specs/ui/desktop-app.md 「SSH 远程后台会话」).
+ * sessions (spec: docs/specs/desktop/desktop-sessions.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.
+ * client detach/attach. A launched daemon is resident: it keeps running (and
+ * generating) while no desktop is connected and never auto-exits once the
+ * work settles. It goes away when told to shut down gracefully (`wave daemon
+ * stop` / `restart`, destroying sessions so transcripts flush), when killed
+ * externally (desktop CLI 升级重启 pkill, remote reboot / machine reboot), and
+ * the next client that finds the socket absent starts a fresh daemon on
+ * demand.
  */
 
 import net from "net";
@@ -24,26 +22,17 @@ 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
@@ -53,20 +42,15 @@ export class DaemonServer {
         for (const conn of this.connections) {
           conn.sendNotification(method, params, sessionId);
         }
-        // Any session activity can change the idle state — re-evaluate.
-        this.evaluateIdle();
       },
+      // The `shutdown` RPC (wave daemon stop/restart) destroys every session in
+      // the bridge, then hands off here to tear the process down.
+      onShutdownRequest: () => this.shutdown(),
     });
     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.
@@ -74,8 +58,6 @@ export class DaemonServer {
       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();
     });
@@ -137,15 +119,10 @@ export class DaemonServer {
     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();
@@ -154,61 +131,28 @@ export class DaemonServer {
     });
   }
 
-  // ── 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.
+   * Graceful process exit for the `shutdown` RPC (`wave daemon stop`/restart).
+   * The bridge has already destroyed every session (each agent saved its
+   * transcript and drained auto-memory); here we drop all client sockets, close
+   * the listener, remove the socket file, then exit. The exit is guarded so a
+   * test process that mocks process.exit (throwing or no-op) still observes the
+   * teardown.
    */
-  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).
+  private shutdown(): void {
     for (const socket of this.sockets) socket.destroy();
     this.sockets.clear();
-    await this.bridge.destroyAll();
-    await this.stop();
+    this.server?.close();
+    this.server = undefined;
     try {
       fs.unlinkSync(this.socketPath);
     } catch {
-      // Already gone — a stale file would be probed/unlinked on next start.
+      // Already gone — a stale file is probed/unlinked on next start.
+    }
+    try {
+      process.exit(0);
+    } catch {
+      // process.exit is mocked in tests — the teardown above is the effect.
     }
-    process.exit(0);
   }
 }

package/src/stdio/protocol.ts

@@ -66,12 +66,19 @@ export type RequestMethod =
   | "getFullMessageThread"
   | "setPermissionMode"
   | "getPermissionMode"
+  | "getPlanFile"
   | "getMcpServers"
   | "connectMcpServer"
   | "disconnectMcpServer"
+  | "removeMcpServer"
+  | "getMcpConfigPaths"
   | "getSlashCommands"
   | "getSubagentConfigurations"
   | "getSkillMetadata"
+  | "deleteSkill"
+  | "deleteSubagent"
+  | "getHooksByScope"
+  | "deleteHook"
   | "searchFiles"
   | "writeArtifactFile"
   | "getPromptHistory"
@@ -85,8 +92,12 @@ export type RequestMethod =
   | "listDaemonSessions"
   // Auth
   | "getAuthStatus"
+  | "getAccountInfo"
   | "login"
   | "logout"
+  // Memory files (user-level ~/.wave/AGENTS.md and project-level <workdir>/AGENTS.md)
+  | "getAgentsContent"
+  | "setAgentsContent"
   // Plugins
   | "listPlugins"
   | "installPlugin"
@@ -106,6 +117,7 @@ export type RequestMethod =
   // Git / worktree (global — no session required)
   | "listGitBranches"
   | "createWorktree"
+  | "getWorktreeChanges"
   | "removeWorktree";
 
 // ── Client → Server notification methods ────────────────────────
@@ -129,9 +141,6 @@ export type ServerNotificationMethod =
   | "permissionModeChange"
   | "mcpServersChange"
   | "workdirChange"
-  | "bangMessageAdded"
-  | "bangMessageUpdated"
-  | "bangMessageCompleted"
   | "notificationMessageAdded"
   | "permissionRequest"
   | "authUrl"
@@ -139,7 +148,8 @@ export type ServerNotificationMethod =
   | "compactionStateChange"
   | "compactionContentUpdate"
   | "backgroundTasksChange"
-  | "btwContent";
+  | "btwContent"
+  | "contextUsage";
 
 // ── Helper: is this a request (has id)? ─────────────────────────
 

package/src/stdio-cli.ts

@@ -7,8 +7,62 @@
  */
 
 import { StdioServer } from "./stdio/stdioServer.js";
+import { logger } from "./utils/logger.js";
+
+/**
+ * Uncaught exceptions / unhandled rejections only print to stderr by
+ * default, which the host truncates to a small tail (and the process exits
+ * right after, so queued stderr can be lost entirely) — the real crash
+ * reason often never reaches the user. Log the full error to cli.log
+ * (synchronous file append, never truncated), best-effort it to stderr,
+ * then keep the exit(1) semantics.
+ */
+function crashHandler(kind: string, error: unknown): void {
+  logger.error(`[stdio] ${kind}:`, error);
+  try {
+    process.stderr.write(
+      `[stdio] ${kind}: ${
+        error instanceof Error ? error.stack || error.message : String(error)
+      }\n`,
+    );
+  } catch {
+    // stderr failure must not mask the log-file entry above.
+  }
+  process.exit(1);
+}
+
+/**
+ * stdout carries the JSON-RPC channel in --stdio mode (one JSON object per
+ * line); stderr is reserved for logger output (see stdioServer.ts). A single
+ * stray `console.log` anywhere in the SDK/host dependency graph therefore
+ * corrupts that channel: the host skips the unparseable line, losing whatever
+ * JSON-RPC payload shared it (this is how `SessionService`'s
+ * `console.log("Restoring session: …")` showed up as
+ * `[wave-jsonrpc] Failed to parse: …` on every restore).
+ *
+ * Fixing individual call sites is a losing race against a graph this big, so
+ * stdio mode forces the contract instead: only `console.error`/`console.warn`
+ * (already stderr) may print, everything else is redirected to stderr.
+ */
+export function guardStdoutForJsonRpc(): void {
+  for (const level of ["log", "info", "debug"] as const) {
+    console[level] = (...args: unknown[]) => {
+      console.error(...args);
+    };
+  }
+}
 
 export async function startStdioCli(): Promise<void> {
+  guardStdoutForJsonRpc();
+  // Registered here (stdio mode only): the interactive CLI keeps Node's
+  // default behavior so the terminal shows the crash stack directly.
+  process.on("uncaughtException", (error) =>
+    crashHandler("uncaughtException", error),
+  );
+  process.on("unhandledRejection", (reason) =>
+    crashHandler("unhandledRejection", reason),
+  );
+
   const server = new StdioServer();
   server.start();
 

package/src/utils/rewindCheckpoints.ts

@@ -3,7 +3,8 @@ import type { Message } from "wave-agent-sdk";
 /**
  * 判断一条 user 消息能否作为 /rewind 检查点。
  * 后台任务通知（task_notification）、hook 注入的消息（source: "hook"）
- * 与 bang 命令消息都是系统生成、用户不可见的，不能作为回滚点。
+ * 都是系统生成、用户不可见的，不能作为回滚点。bash 模式命令消息
+ * （`!ls`）是用户真正输入，与 fork skill 命令消息一致，可作为回滚点。
  * CLI 交互式选择器与 stdio listRewindCheckpoints 共用此判定，避免两处漂移。
  */
 export function isUserCheckpointMessage(m: Message): boolean {
@@ -11,6 +12,5 @@ export function isUserCheckpointMessage(m: Message): boolean {
   if (m.blocks.some((b) => b.type === "task_notification")) return false;
   if (m.blocks.some((b) => b.type === "text" && b.source === "hook"))
     return false;
-  if (m.blocks.some((b) => b.type === "bang")) return false;
   return true;
 }

package/src/utils/worktree.ts

@@ -323,6 +323,132 @@ function toExtendedLengthPath(worktreePath: string): string {
   return `\\\\?\\${absolute}`;
 }
 
+/** First line of a captured stderr/message, trimmed and length-capped. */
+function firstLine(text: string | undefined, max = 200): string {
+  if (!text) return "";
+  const line = text.trim().split("\n")[0].trim();
+  return line.length > max ? `${line.slice(0, max)}…` : line;
+}
+
+/**
+ * Summarise why `git worktree remove` failed. execFile rejections carry the
+ * exit code and the child's stderr; without them a removal failure is
+ * indistinguishable from a MAX_PATH refusal, a locking process, or a git error.
+ */
+function describeGitFailure(error: unknown): string {
+  const e = error as {
+    code?: number | string;
+    signal?: string;
+    stderr?: string;
+    message?: string;
+  };
+  const parts: string[] = [];
+  if (e.code !== undefined) parts.push(`code=${e.code}`);
+  if (e.signal) parts.push(`signal=${e.signal}`);
+  const stderr = firstLine(e.stderr);
+  if (stderr) parts.push(`stderr=${stderr}`);
+  if (parts.length === 0) parts.push(`message=${firstLine(e.message)}`);
+  return parts.join(" ");
+}
+
+/** Summarise why the `fs.rmSync` fallback failed (code + offending path). */
+function describeFsFailure(error: unknown): string {
+  const e = error as {
+    code?: string;
+    syscall?: string;
+    path?: string;
+    message?: string;
+  };
+  const parts: string[] = [];
+  if (e.code) parts.push(`code=${e.code}`);
+  if (e.syscall) parts.push(`syscall=${e.syscall}`);
+  if (e.path) parts.push(`at=${e.path}`);
+  if (parts.length === 0) parts.push(`message=${firstLine(e.message)}`);
+  return parts.join(" ");
+}
+
+/**
+ * Delete the worktree directory with `fs.rmSync`, returning the error when it
+ * fails (null on success). Node removes directory symlinks/junctions properly,
+ * which is exactly where git gives up on Windows.
+ */
+function rmWorktreeDirWithFs(worktreePath: string): unknown | null {
+  try {
+    fs.rmSync(toExtendedLengthPath(worktreePath), {
+      recursive: true,
+      force: true,
+    });
+    return null;
+  } catch (error) {
+    return error;
+  }
+}
+
+/**
+ * Describe what is still on disk after a failed removal. Without this a
+ * failure log cannot distinguish "directory already gone" from "the whole
+ * checkout is still sitting there".
+ */
+function probeResidue(worktreePath: string): string {
+  try {
+    if (!fs.existsSync(worktreePath)) return "none";
+    const entries = fs.readdirSync(worktreePath) as string[];
+    const head = entries.slice(0, 5).join(",");
+    return `${entries.length}[${head}${entries.length > 5 ? ",…" : ""}]`;
+  } catch (error) {
+    return `unknown(${(error as { code?: string }).code ?? "error"})`;
+  }
+}
+
+export interface WorktreeChanges {
+  /** Uncommitted (tracked-modified or untracked) files in the worktree. */
+  files: number;
+  /** Commits on the checked-out branch that the base branch does not have. */
+  commits: number;
+}
+
+/**
+ * Count what deleting a worktree would throw away, so the caller can warn
+ * before it happens. Both counts are best-effort: an unknown base branch (never
+ * fetched, branch rewritten) only zeroes the commit count, and a worktree that
+ * is gone or not a git repository reports `null` instead of a misleading 0.
+ *
+ * @param worktreePath Worktree directory to inspect
+ * @param baseBranch Branch the worktree was created from (defaults to the
+ *   repository's default remote branch)
+ */
+export async function getWorktreeChanges(
+  worktreePath: string,
+  baseBranch?: string,
+): Promise<WorktreeChanges | null> {
+  let files: number;
+  try {
+    const { stdout } = await execFileAsync("git", ["status", "--porcelain"], {
+      cwd: worktreePath,
+      encoding: "utf8",
+    });
+    files = stdout.split("\n").filter((line) => line.trim().length > 0).length;
+  } catch {
+    return null;
+  }
+
+  let commits = 0;
+  try {
+    const base = baseBranch ?? getDefaultRemoteBranch(worktreePath);
+    const { stdout } = await execFileAsync(
+      "git",
+      ["rev-list", "--count", `${base}..HEAD`],
+      { cwd: worktreePath, encoding: "utf8" },
+    );
+    commits = Number.parseInt(stdout.trim(), 10) || 0;
+  } catch {
+    // Unknown base (e.g. the branch was never fetched): the commit count is
+    // unknowable, but the uncommitted files below are still real.
+  }
+
+  return { files, commits };
+}
+
 /**
  * Remove a git worktree and its associated branch
  * @param session Worktree session details
@@ -332,7 +458,8 @@ function toExtendedLengthPath(worktreePath: string): string {
  * is MAX_PATH-limited — deep paths (e.g. node_modules) can fail with "Filename
  * too long", leaving an orphan directory. When git fails we fall back to
  * fs.rmSync with an extended-length path (bypasses MAX_PATH) and prune stale
- * metadata. Failures are logged but never block branch deletion.
+ * metadata. Failures are logged; when the directory survives, its branch is
+ * deliberately kept so the leftover checkout stays reachable through git.
  */
 export async function removeWorktree(session: WorktreeSession): Promise<void> {
   // Hook-based worktrees are removed by the WorktreeRemove hook; wave never
@@ -359,22 +486,6 @@ export async function removeWorktree(session: WorktreeSession): Promise<void> {
 
   const repoRoot = session.repoRoot;
 
-  // Get current branch in worktree before removing it
-  let currentBranch: string | undefined;
-  try {
-    const { stdout } = await execFileAsync(
-      "git",
-      ["rev-parse", "--abbrev-ref", "HEAD"],
-      {
-        cwd: session.path,
-        encoding: "utf8",
-      },
-    );
-    currentBranch = stdout.trim();
-  } catch {
-    // Ignore errors getting current branch
-  }
-
   // Remove worktree
   try {
     await execFileAsync(
@@ -384,18 +495,42 @@ export async function removeWorktree(session: WorktreeSession): Promise<void> {
         cwd: repoRoot,
       },
     );
+    // git exits 0 even when it did not delete the directory: on Windows it
+    // cannot remove directory symlinks/junctions, which is exactly what pnpm's
+    // node_modules is made of — so it deletes the files, leaves the skeleton
+    // behind and still reports success. Trust the filesystem, not the exit code.
+    if (fs.existsSync(session.path)) {
+      logger.warn(
+        `git worktree remove reported success but the directory survived: ` +
+          `path=${session.path} residue=${probeResidue(session.path)} — ` +
+          `deleting with fs.rmSync instead`,
+      );
+      const rmError = rmWorktreeDirWithFs(session.path);
+      if (rmError) {
+        logger.error(
+          `Failed to remove worktree or branch: path=${session.path} ` +
+            `stage=fs(after git success) ${describeFsFailure(rmError)} ` +
+            `residue=${probeResidue(session.path)}`,
+          rmError,
+        );
+      }
+    }
   } catch (error: unknown) {
     logger.warn(
-      "git worktree remove failed, falling back to fs.rmSync:",
+      `git worktree remove failed, falling back to fs.rmSync: ${describeGitFailure(error)}`,
       error,
     );
-    try {
-      fs.rmSync(toExtendedLengthPath(session.path), {
-        recursive: true,
-        force: true,
-      });
-    } catch (rmError: unknown) {
-      logger.error("Failed to remove worktree or branch:", rmError);
+    const rmError = rmWorktreeDirWithFs(session.path);
+    if (rmError) {
+      // Removal failures are best-effort, so this line is often the only trace
+      // of an orphaned worktree directory: record which stage failed, why, and
+      // whether anything was left behind.
+      logger.error(
+        `Failed to remove worktree or branch: path=${session.path} stage=fs ` +
+          `${describeFsFailure(rmError)} residue=${probeResidue(session.path)} ` +
+          `git(${describeGitFailure(error)})`,
+        rmError,
+      );
     }
     // git removes worktree metadata before the working directory; prune any
     // leftovers in case git failed before deleting them.
@@ -408,7 +543,21 @@ export async function removeWorktree(session: WorktreeSession): Promise<void> {
     }
   }
 
-  // Delete original branch
+  // The directory, not any exit code, decides whether the removal happened. A
+  // surviving directory means its checkout (and any uncommitted work in it) is
+  // still on disk, and the branch is the only ref still leading back to it.
+  if (fs.existsSync(session.path)) {
+    logger.warn(
+      `Worktree directory survived removal — keeping ${session.branch} so the ` +
+        `leftover checkout stays reachable: path=${session.path} ` +
+        `residue=${probeResidue(session.path)}`,
+    );
+    return;
+  }
+
+  // Delete the worktree's own branch. Branches the user checked out inside the
+  // worktree are never touched — they may hold commits that are not reachable
+  // from anywhere else (aligned with Claude Code).
   try {
     await execFileAsync("git", ["branch", "-D", session.branch], {
       cwd: repoRoot,
@@ -416,28 +565,4 @@ export async function removeWorktree(session: WorktreeSession): Promise<void> {
   } catch {
     // Ignore errors deleting original branch
   }
-
-  // Delete current branch if it's different and not a protected branch
-  if (
-    currentBranch &&
-    currentBranch !== session.branch &&
-    currentBranch !== "HEAD"
-  ) {
-    const defaultRemoteBranch = getDefaultRemoteBranch(repoRoot);
-    const defaultBranchName = defaultRemoteBranch.split("/").pop();
-
-    if (
-      currentBranch !== defaultBranchName &&
-      currentBranch !== "main" &&
-      currentBranch !== "master"
-    ) {
-      try {
-        await execFileAsync("git", ["branch", "-D", currentBranch], {
-          cwd: repoRoot,
-        });
-      } catch {
-        // Ignore errors deleting current branch
-      }
-    }
-  }
 }

package/src/components/BangDisplay.tsx

@@ -1,41 +0,0 @@
-import React from "react";
-import { Box, Text } from "ink";
-import type { BangBlock } from "wave-agent-sdk";
-import { getLastLines } from "wave-agent-sdk";
-
-interface BangDisplayProps {
-  block: BangBlock;
-  isExpanded?: boolean;
-}
-
-export const BangDisplay: React.FC<BangDisplayProps> = ({
-  block,
-  isExpanded = false,
-}) => {
-  const { command, output, stage, exitCode } = block;
-  const MAX_LINES = 3; // Set maximum display lines
-
-  const getStatusColor = () => {
-    if (stage === "running") return "yellow";
-    if (exitCode === 0) return "green";
-    if (exitCode !== null && exitCode !== 0) return "red";
-    return "gray"; // Unknown state
-  };
-
-  return (
-    <Box flexDirection="column">
-      <Box>
-        <Text color={getStatusColor()}>! </Text>
-        <Text color="white">{command}</Text>
-      </Box>
-
-      {output && (
-        <Box paddingLeft={2} overflow="hidden">
-          <Text color="gray">
-            {isExpanded ? output : getLastLines(output, MAX_LINES)}
-          </Text>
-        </Box>
-      )}
-    </Box>
-  );
-};