wave-code 1.5.1 → 1.6.1

package/src/daemon/commands.ts

@@ -13,8 +13,11 @@
  * 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).
+ * socket — `~/.wave/daemon.sock` on POSIX, its named-pipe form on Windows (see
+ * ./socketPath.ts) — and no `--socket` override is offered, so the same commands
+ * address this machine's daemon whether it hosts remote-background sessions or
+ * the local delegation sessions the wave-daemon skill creates
+ * (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
@@ -25,9 +28,9 @@
  * must be destroyed via the envelope sessionId returned by `initialize`.
  */
 
-import { execFile, spawn } from "node:child_process";
+import { execFile, spawn, type ChildProcess } from "node:child_process";
+import * as fs from "node:fs";
 import net from "node:net";
-import os from "node:os";
 import path from "node:path";
 import {
   ASK_USER_QUESTION_TOOL_NAME,
@@ -44,13 +47,22 @@ import {
   type ToolPermissionContext,
 } from "wave-agent-sdk";
 import { SocketClient } from "./socketClient.js";
+import {
+  openDaemonLogForChild,
+  readDaemonLogTail,
+  type DaemonLogHandle,
+} from "./daemonLog.js";
+import {
+  describeWorktreeSurvival,
+  worktreeCreationBranch,
+} from "../utils/worktree.js";
 
-/** Fixed default daemon socket (spec: 默认 socket 固定，无 --socket 覆盖). */
-export const DEFAULT_DAEMON_SOCKET = path.join(
-  os.homedir(),
-  ".wave",
-  "daemon.sock",
-);
+/**
+ * Fixed default daemon socket (spec: 默认 socket 固定，无 --socket 覆盖). The
+ * shape is platform-dependent — a file socket on POSIX, a named pipe on Windows —
+ * and both sides derive it from the same function (see ./socketPath.ts).
+ */
+export { DEFAULT_DAEMON_SOCKET } from "./socketPath.js";
 
 const PERMISSION_MODES: PermissionMode[] = [
   "default",
@@ -64,6 +76,16 @@ const PERMISSION_MODES: PermissionMode[] = [
 export const daemonStartTimeout = { ms: 10_000 };
 const DAEMON_POLL_INTERVAL_MS = 500;
 
+/**
+ * After the launched daemon has already exited nonzero, how much longer to keep
+ * trying the socket before giving up. Concurrent clients each launch a daemon and
+ * exactly one wins — the loser sees its own child refused ("another daemon is
+ * already listening") while the winner may still be coming up, so this window
+ * lets it join instead of reporting a failure for a daemon that is fine.
+ * (Mutable so tests can shorten it.)
+ */
+export const daemonExitGrace = { ms: 1_500 };
+
 // ── Connection helpers ─────────────────────────────────────────
 
 function connectDaemon(socketPath: string): Promise<SocketClient> {
@@ -77,6 +99,12 @@ function connectDaemon(socketPath: string): Promise<SocketClient> {
   });
 }
 
+/** The launched daemon child plus the log handle its stderr was sent to. */
+interface LaunchedDaemon {
+  child: ChildProcess;
+  log: DaemonLogHandle | undefined;
+}
+
 /**
  * Start a wave daemon on demand, detached — the local equivalent of the remote
  * nohup launcher `nohup <wave> --daemon <socket> </dev/null >/dev/null 2>&1 &`
@@ -84,24 +112,64 @@ function connectDaemon(socketPath: string): Promise<SocketClient> {
  * <this script> --daemon <socket>`) with no stdio and unrefs the child so the
  * client exits without waiting; the daemon cleans stale socket files itself on
  * start.
+ *
+ * stderr goes to `~/.wave/logs/daemon.log` rather than to a pipe: the daemon is
+ * resident and outlives this client, and a write to a closed pipe (EPIPE) could
+ * take it down. The file is what makes a failed start diagnosable — the real
+ * cause lives in the dead child's stderr.
  */
-function startDaemon(socketPath: string): void {
+function startDaemon(socketPath: string): LaunchedDaemon {
   const entry = process.argv[1];
   if (!entry) {
     fail("Cannot start the wave daemon: unknown CLI entry path");
   }
+  const log = openDaemonLogForChild();
   const child = spawn(process.execPath, [entry, "--daemon", socketPath], {
     detached: true,
-    stdio: "ignore",
+    stdio: ["ignore", "ignore", log ? log.fd : "ignore"],
   });
+  if (log) {
+    // The child holds its own duplicate of the descriptor.
+    try {
+      fs.closeSync(log.fd);
+    } catch {
+      // Already closed — nothing to hand back to the caller either way.
+    }
+  }
   child.unref();
+  return { child, log };
+}
+
+/**
+ * The client-side failure text for an on-demand start that never became
+ * reachable. When the child exited we report *that* (exit code plus the last line
+ * it wrote to the log); otherwise the daemon is still alive but slow to come up,
+ * and the text keeps the original shape plus the first connect error code.
+ */
+function describeStartFailure(
+  socketPath: string,
+  firstErrorCode: string | undefined,
+  exitCode: number | null | undefined,
+  logTail: string,
+): string {
+  const reason =
+    exitCode === undefined
+      ? `started a daemon but it did not come up${
+          firstErrorCode ? ` (${firstErrorCode})` : ""
+        }`
+      : `the daemon process exited with code ${exitCode}`;
+  return `Cannot connect to daemon socket ${socketPath}: ${reason}${
+    logTail ? ` — ${logTail}` : ""
+  }`;
 }
 
 /**
  * Connect or start the daemon on demand: try the socket, and when the daemon is
  * not running, launch one detached and retry until its socket accepts a
- * connection (or daemonStartTimeout.ms elapses). Exits (nonzero) with the
- * spec'd error when the daemon cannot be started/reached.
+ * connection (or daemonStartTimeout.ms elapses). A child that exits during the
+ * wait fails fast (after a short grace window for the concurrent-start race) and
+ * its own stderr is reported. Exits (nonzero) with the spec'd error when the
+ * daemon cannot be started/reached.
  */
 export async function connectDaemonOrExit(
   socketPath: string,
@@ -109,8 +177,12 @@ export async function connectDaemonOrExit(
   try {
     return await connectDaemon(socketPath);
   } catch (err) {
-    const code = (err as NodeJS.ErrnoException).code;
-    startDaemon(socketPath);
+    const firstErrorCode = (err as NodeJS.ErrnoException).code;
+    const { child, log } = startDaemon(socketPath);
+    let exitCode: number | null | undefined;
+    child.once("exit", (code) => {
+      exitCode = code;
+    });
     const deadline = Date.now() + daemonStartTimeout.ms;
     while (Date.now() < deadline) {
       await sleep(DAEMON_POLL_INTERVAL_MS);
@@ -119,10 +191,29 @@ export async function connectDaemonOrExit(
       } catch {
         // Daemon still coming up — keep polling.
       }
+      if (exitCode !== undefined) {
+        // The process that was supposed to serve this socket is gone. Keep
+        // trying for a moment (another client's daemon may be the one coming
+        // up), then fail immediately instead of waiting out the full timeout.
+        const graceEnd = Date.now() + daemonExitGrace.ms;
+        while (Date.now() < graceEnd) {
+          try {
+            return await connectDaemon(socketPath);
+          } catch {
+            // Nothing listening yet.
+          }
+          await sleep(DAEMON_POLL_INTERVAL_MS);
+        }
+        break;
+      }
     }
     console.error(
-      `Cannot connect to daemon socket ${socketPath}: started a daemon but it did not come up` +
-        (code ? ` (${code})` : ""),
+      describeStartFailure(
+        socketPath,
+        firstErrorCode,
+        exitCode,
+        readDaemonLogTail(log),
+      ),
     );
     process.exit(1);
   }
@@ -883,6 +974,57 @@ export async function daemonWaitCommand(
       });
     };
 
+    // The second way `--from-busy` learns that the busy phase HAPPENED: a turn
+    // that both started and ended before this client attached leaves nothing to
+    // observe — the replayed snapshot is idle, no `loadingChange:true` arrives,
+    // and every registry read says idle — so `sawBusy` can never become true.
+    // `wave daemon send <id> …; sleep 8; wave daemon wait <id> --from-busy`, the
+    // ordinary way to fetch a delegated report, hung until `--timeout` (default:
+    // never) because of exactly that (issue #2744). The finished turn is still
+    // visible in the session's own transcript, so ask it: a dispatched turn that
+    // produced anything (reply, tool call, or the notice a failed turn ends
+    // with — all of them live in an assistant message) leaves that assistant
+    // message last, while an unstarted dispatch leaves the user message last.
+    //
+    // The transcript, not a counter in the registry, because: re-hosting a
+    // session (`initialize` + `restoreSession` on attach, after a daemon
+    // restart) rebuilds the agent from disk, so anything the daemon counts in
+    // memory restarts at zero while the transcript still answers the question;
+    // and the daemon is long-lived, so a new CLI has to work against one started
+    // by an older version — a transcript read needs no new field on the wire.
+    // Memoized on the registry's `messageCount` (thread-wide, so it moves
+    // whenever a message is appended) because the loop asks again on every idle
+    // read while it holds: copying a long conversation every 2s buys nothing.
+    let finishedTurn:
+      | { sessionId: string; messageCount: number; value: boolean }
+      | undefined;
+    const turnAlreadyFinished = async (
+      entry: DaemonSessionEntry,
+    ): Promise<boolean> => {
+      const known = finishedTurn;
+      if (
+        known &&
+        known.sessionId === watch.id &&
+        known.messageCount === entry.messageCount
+      ) {
+        return known.value;
+      }
+      const result = (await read(
+        (id) =>
+          socket.request("getMessages", undefined, id) as Promise<{
+            messages: Message[];
+          }>,
+      )) as { messages?: Message[] };
+      const newest = (result.messages ?? []).at(-1);
+      const value = newest?.role === "assistant";
+      finishedTurn = {
+        sessionId: watch.id,
+        messageCount: entry.messageCount,
+        value,
+      };
+      return value;
+    };
+
     const deadline =
       timeoutMs !== undefined ? Date.now() + timeoutMs : undefined;
     let announced = false;
@@ -935,10 +1077,17 @@ export async function daemonWaitCommand(
       }
       // Idle comes from the registry, never from a single push: already idle at
       // call time settles immediately — never hanging beats winning the race.
-      // --from-busy holds out for an observed busy phase first: right after an
-      // async `send` the replayed snapshot can still be a stale loading:false
-      // (the turn has not started yet).
-      if (idle && (!fromBusy || sawBusy)) {
+      // --from-busy holds out for evidence that the busy phase happened first:
+      // either it was observed (see `sawBusy`), or the turn it was waiting on
+      // has already finished and left its reply in the transcript (see
+      // `turnAlreadyFinished` — the `send` → `sleep` → `wait` shape). Without
+      // that second signal, a turn that started and ended before the attach
+      // reads as "busy never happened" and the waiter rejects the idle in front
+      // of it forever.
+      if (
+        idle &&
+        (!fromBusy || sawBusy || (await turnAlreadyFinished(hosted)))
+      ) {
         await settle("idle", []);
         break;
       }
@@ -1276,7 +1425,7 @@ export interface DestroyOptions {
 /** Run one git command and return trimmed stdout (rejects on git failure). */
 function runGit(cwd: string, args: string[]): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("git", args, { cwd }, (err, stdout) => {
+    execFile("git", args, { cwd, windowsHide: true }, (err, stdout) => {
       if (err) reject(err);
       else resolve(stdout.trim());
     });
@@ -1286,28 +1435,33 @@ function runGit(cwd: string, args: string[]): Promise<string> {
 /**
  * Resolve the worktree hosting `sessionCwd` for removal, mirroring the
  * values protocol createWorktree returns: worktree path via
- * `git rev-parse --show-toplevel`, branch via `git branch --show-current`, and
- * repoRoot = the MAIN repo root (first entry of `git worktree list` — where
+ * `git rev-parse --show-toplevel` and repoRoot = the MAIN repo root (where
  * git worktree/branch operations run from). Refuses to remove the main working
  * tree: a plain session is not a worktree, and the protocol's path-containment
  * check would pass trivially while removeWorktree's fs.rmSync fallback could
  * delete the whole repository.
+ *
+ * The branch comes from `createdBranch` (the session's creation-time snapshot,
+ * see `SessionEntry.createdWorktreeBranch`) or from the worktree's path layout
+ * — never from `git branch --show-current`. That last one answers "what is
+ * checked out here now", and an agent that ran `git checkout <other-branch>`
+ * inside the worktree makes it name the user's branch: deleting that would
+ * throw away commits reachable from nowhere else while the `worktree-<name>`
+ * branch stays behind as the orphan (aligned with Claude Code, which deletes
+ * the branch it recorded when it created the worktree).
  */
-async function resolveWorktreeForRemoval(sessionCwd: string): Promise<{
+async function resolveWorktreeForRemoval(
+  sessionCwd: string,
+  createdBranch?: string,
+): Promise<{
   path: string;
   branch: string;
   repoRoot: string;
   hookBased: boolean;
 }> {
   let worktreePath: string;
-  let branch: string;
   try {
-    const [toplevel, current] = await Promise.all([
-      runGit(sessionCwd, ["rev-parse", "--show-toplevel"]),
-      runGit(sessionCwd, ["branch", "--show-current"]),
-    ]);
-    worktreePath = toplevel;
-    branch = current;
+    worktreePath = await runGit(sessionCwd, ["rev-parse", "--show-toplevel"]);
   } catch {
     throw new Error(
       `Cannot remove worktree: ${sessionCwd} is not inside a git repository`,
@@ -1324,17 +1478,55 @@ async function resolveWorktreeForRemoval(sessionCwd: string): Promise<{
   // removal never runs `git worktree remove` on a hook-managed worktree.
   const config = loadMergedWaveConfig(repoRoot);
   const hookBased = hasWorktreeCreateHook(config?.hooks);
+  // Empty when neither record can name the branch: removal then deletes the
+  // worktree and keeps every branch, rather than guessing at one. A name that
+  // came from the path layout is only a candidate — `removeWorktree` asks git
+  // whether this repository really has that branch before deleting anything.
+  const branch =
+    createdBranch ||
+    worktreeCreationBranch({ path: worktreePath, repoRoot }) ||
+    "";
   return { path: worktreePath, branch, repoRoot, hookBased };
 }
 
+/**
+ * Report a worktree that removal left on disk.
+ *
+ * Two things must be true at once: the session IS destroyed (so this cannot read
+ * as a failed command), and the leftover directory must be visible without
+ * digging through `~/.wave/logs/daemon.log` (which is where `removeWorktree`
+ * puts its only trace of it). Stderr carries the warning and the manual cleanup
+ * commands, because the branch is deliberately kept for the leftover checkout.
+ */
+function reportSurvivingWorktree(worktree: {
+  path: string;
+  branch: string;
+  repoRoot: string;
+}): void {
+  console.error(describeWorktreeSurvival(worktree));
+}
+
 /**
  * Destroy a hosted session (protocol destroy, idempotent — a session not in
  * the daemon's in-memory registry is a harmless no-op). Unlike status / send /
  * abort there is no attach step: destroy is a pure registry operation keyed by
  * the envelope sessionId, so unknown sessions succeed without touching disk.
+ *
  * With --remove-worktree the session's git worktree is resolved from its
- * sessionCwd (getSessionInfo) and removed via protocol removeWorktree
- * first, then the session is destroyed.
+ * sessionCwd (getSessionInfo) and validated **first** — the refusals (not a
+ * repository / this is the main working tree) must leave the session intact —
+ * but the session is destroyed **before** the worktree directory is removed.
+ * The order is the fix for issue #2763: the session's own processes (a Bash
+ * shell, a test runner, `node --watch`) hold the worktree as their cwd, and
+ * Windows refuses to delete a directory a live process sits in — so removing it
+ * first "succeeded" in the report while the directory and its branch were still
+ * there. `agent.destroy()` kills those processes; only then is the directory
+ * deletable. On POSIX both orders work, which is exactly why this went unnoticed.
+ *
+ * The worktree line reports what happened, not what was attempted: `removeWorktree`
+ * is best-effort, so a surviving directory (and the branch kept for it) is
+ * reported on stderr with the commands that finish the job instead of a
+ * "Removed worktree" line for something that is still on disk.
  */
 export async function daemonDestroyCommand(
   socketPath: string,
@@ -1344,23 +1536,53 @@ export async function daemonDestroyCommand(
   let client: SocketClient | undefined;
   try {
     client = await connectDaemonOrExit(socketPath);
+    // Resolve before destroying: both refusals inside mean "do nothing at
+    // all", and a session that is already gone cannot be resolved any more.
+    let worktree:
+      | Awaited<ReturnType<typeof resolveWorktreeForRemoval>>
+      | undefined;
     if (options.removeWorktree) {
       const info = (await client.request(
         "getSessionInfo",
         undefined,
         sessionId,
-      )) as { sessionCwd: string };
-      const wt = await resolveWorktreeForRemoval(info.sessionCwd);
-      await client.request("removeWorktree", {
-        path: wt.path,
-        branch: wt.branch,
-        repoRoot: wt.repoRoot,
-        hookBased: wt.hookBased,
-      });
-      console.log(`Removed worktree: ${wt.path} (branch: ${wt.branch})`);
+      )) as { sessionCwd: string; worktreeBranch?: string };
+      worktree = await resolveWorktreeForRemoval(
+        info.sessionCwd,
+        info.worktreeBranch,
+      );
     }
     await client.request("destroy", undefined, sessionId);
     console.log(`Destroyed session: ${sessionId}`);
+    if (worktree) {
+      try {
+        // `removed` is undefined when talking to a daemon from before it
+        // reported an outcome (the daemon outlives CLI upgrades): then the old
+        // unconditional line is all this client can honestly say.
+        const reply = (await client.request("removeWorktree", {
+          path: worktree.path,
+          branch: worktree.branch,
+          repoRoot: worktree.repoRoot,
+          hookBased: worktree.hookBased,
+        })) as { removed?: boolean } | undefined;
+        if (reply?.removed === false) {
+          reportSurvivingWorktree(worktree);
+        } else {
+          // An empty branch means nothing could name the branch the worktree
+          // was created on — the worktree is gone and every branch was kept,
+          // which the caller must be able to see rather than guess at.
+          console.log(
+            `Removed worktree: ${worktree.path} (branch: ${worktree.branch || "none deleted"})`,
+          );
+        }
+      } catch (err) {
+        // The session is already gone, so reporting a failed `destroy` here
+        // would send the caller to retry something that cannot succeed (the id
+        // no longer resolves). Say what is true and how to finish by hand.
+        console.error(`Worktree removal failed: ${(err as Error).message}`);
+        reportSurvivingWorktree(worktree);
+      }
+    }
   } catch (err) {
     fail(`wave daemon destroy failed: ${(err as Error).message}`);
   } finally {

package/src/daemon/daemonLog.ts

@@ -0,0 +1,132 @@
+/**
+ * The daemon's stderr log — the only channel back from a process whose stdio the
+ * client deliberately does not hold open.
+ *
+ * `wave daemon <subcommand>` launches the daemon detached and unref'd; the daemon
+ * outlives the client by design (it is resident). Keeping a pipe on its stderr
+ * would therefore be wrong: once the client exits, the daemon's next write hits
+ * EPIPE and can take a long-lived process down. A log file has no such coupling,
+ * and it is also what makes an on-demand start failure diagnosable at all — the
+ * real cause (`listen EACCES`, a dependency install failure, …) lives in the dead
+ * child's stderr, and without the file the client could only report the error
+ * code of its own first connect attempt.
+ *
+ * The tail is read from the offset captured at launch, so the reported line is
+ * this launch's stderr rather than whatever a previous launch left behind.
+ *
+ * `WAVE_LOGS_DIR` redirects the directory (same convention as the desktop and VS
+ * Code host logs), which is what tests and isolated-HOME runs use.
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getLastLines, stripAnsiColors } from "wave-agent-sdk";
+
+/** Rotate one generation (to `daemon.log.1`) once the log passes this size. */
+export const DAEMON_LOG_MAX_BYTES = 1024 * 1024;
+
+/** How many trailing bytes are read to find the last diagnostic line. */
+const TAIL_READ_BYTES = 8 * 1024;
+
+export function daemonLogDir(): string {
+  return process.env.WAVE_LOGS_DIR || path.join(os.homedir(), ".wave", "logs");
+}
+
+export function daemonLogFile(): string {
+  return path.join(daemonLogDir(), "daemon.log");
+}
+
+/** The single retained previous generation (`daemon.log.1`). */
+function rotatedLogFile(file: string): string {
+  return `${file}.1`;
+}
+
+/**
+ * Best-effort one-generation rotation before appending. Failures are swallowed:
+ * the log is a diagnostic aid, never a reason for the daemon not to start.
+ */
+export function rotateDaemonLog(
+  file = daemonLogFile(),
+  maxBytes = DAEMON_LOG_MAX_BYTES,
+): void {
+  try {
+    if (fs.statSync(file).size <= maxBytes) return;
+    // Windows refuses to rename over an existing file — drop the old generation
+    // first (and POSIX does not mind).
+    fs.rmSync(rotatedLogFile(file), { force: true });
+    fs.renameSync(file, rotatedLogFile(file));
+  } catch {
+    // Nothing to rotate yet, or the directory is not writable.
+  }
+}
+
+/**
+ * An open append handle for a launched daemon child, plus the offset its output
+ * starts at (the file is shared across launches).
+ */
+export interface DaemonLogHandle {
+  fd: number;
+  file: string;
+  offset: number;
+}
+
+/**
+ * Open (and if needed rotate) the daemon log, returning the handle to pass as
+ * the child's stderr — or `undefined` when it cannot be opened, in which case the
+ * caller falls back to `"ignore"` and simply loses the diagnostic.
+ */
+export function openDaemonLogForChild(
+  file = daemonLogFile(),
+): DaemonLogHandle | undefined {
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    rotateDaemonLog(file);
+    const offset = fs.existsSync(file) ? fs.statSync(file).size : 0;
+    const fd = fs.openSync(file, "a");
+    return { fd, file, offset };
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * The last non-empty line this launch wrote, de-ANSI'd, collapsed to one line and
+ * capped — meant to be appended to a client-side error message. Empty when there
+ * is no handle or nothing was written.
+ */
+export function readDaemonLogTail(
+  handle: DaemonLogHandle | undefined,
+  maxChars = 200,
+): string {
+  if (!handle) return "";
+  let fd: number | undefined;
+  try {
+    fd = fs.openSync(handle.file, "r");
+    const size = fs.fstatSync(fd).size;
+    const from = Math.max(handle.offset, size - TAIL_READ_BYTES);
+    const bytes = size - from;
+    if (bytes <= 0) return "";
+    const buf = Buffer.alloc(bytes);
+    fs.readSync(fd, buf, 0, bytes, from);
+    const lines = getLastLines(buf.toString("utf8"), 20).split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = stripAnsiColors(lines[i] ?? "")
+        .replace(/\s+/g, " ")
+        .trim();
+      if (!line) continue;
+      return line.length > maxChars ? `${line.slice(0, maxChars)}…` : line;
+    }
+    return "";
+  } catch {
+    return "";
+  } finally {
+    if (fd !== undefined) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+        // Already closed.
+      }
+    }
+  }
+}