wave-code 1.0.9 → 1.1.0

package/src/session-selector-cli.tsx

@@ -1,41 +1,282 @@
-import React from "react";
-import { render, Box } from "ink";
-import { listSessions, truncateContent } from "wave-agent-sdk";
+import React, { useState, useCallback, useEffect, useRef } from "react";
+import { render, Box, Text } from "ink";
+import { existsSync } from "fs";
+import {
+  PathEncoder,
+  listSessions,
+  listAllSessions,
+  truncateContent,
+  type SessionMetadata,
+} from "wave-agent-sdk";
 import { SessionSelector } from "./components/SessionSelector.js";
+import { setClipboardText } from "./utils/clipboard.js";
+
+export interface SessionSelectorResult {
+  sessionId: string;
+  /**
+   * When the selected session belongs to a sibling git worktree of the same
+   * repo, the caller should chdir into this path before restoring.
+   */
+  resumeWorkdir?: string;
+}
+
+type SessionItem = SessionMetadata & { firstMessage?: string };
+
+/** POSIX single-quote wrapping for use inside a `cd <path> && ...` command. */
+function quotePath(p: string): string {
+  return `'${p.replace(/'/g, `'\\''`)}'`;
+}
+
+export type SessionOwnership =
+  | { kind: "current" }
+  | { kind: "worktree"; resumeWorkdir: string }
+  | { kind: "cross-project"; command: string };
+
+/**
+ * Decide how a selected session relates to the current working directory.
+ *
+ * Ownership is decided by comparing encoded directory names — the decoded
+ * workdir is lossy for paths containing "-", but re-encoding it reproduces the
+ * original encoded directory name exactly.
+ *
+ * - current:      session belongs to the current directory → resume in place
+ * - worktree:     session belongs to a sibling same-repo worktree → resume
+ *                 after chdir into it (skipped when the worktree dir is gone)
+ * - cross-project: session belongs to another project → print a cd command
+ */
+export async function resolveSessionOwnership(
+  session: { id: string; workdir: string },
+  opts: { worktreePaths: string[]; currentWorkdir: string },
+): Promise<SessionOwnership> {
+  const encoder = new PathEncoder();
+  // encode() resolves the path via realpath and throws ENOENT when the
+  // directory no longer exists (e.g. a deleted worktree); fall back to the
+  // pure string encodeSync so the picker still works for ghost sessions.
+  let sessionEncoded: string;
+  try {
+    sessionEncoded = await encoder.encode(session.workdir);
+  } catch {
+    sessionEncoded = encoder.encodeSync(session.workdir);
+  }
+  const cwdEncoded = await encoder.encode(opts.currentWorkdir);
+
+  if (sessionEncoded === cwdEncoded) {
+    return { kind: "current" };
+  }
+
+  for (const wt of opts.worktreePaths) {
+    let wtEncoded: string;
+    try {
+      wtEncoded = await encoder.encode(wt);
+    } catch {
+      wtEncoded = encoder.encodeSync(wt);
+    }
+    if (wtEncoded === sessionEncoded && existsSync(wt)) {
+      return { kind: "worktree", resumeWorkdir: wt };
+    }
+  }
+
+  return {
+    kind: "cross-project",
+    command: `cd ${quotePath(session.workdir)} && wave --restore ${session.id}`,
+  };
+}
+
+/**
+ * Interactive session picker for `wave -r` (restore without an ID).
+ *
+ * Three scopes, toggled with Ctrl+A / Ctrl+W (mirroring Claude Code's resume
+ * picker):
+ * - current:   sessions in the current working directory (default)
+ * - worktrees: sessions in any worktree of the same git repository
+ * - all:       sessions across every project directory
+ *
+ * Resume decision on selection:
+ * - current dir session      → resume in place
+ * - same-repo worktree       → resume after chdir into that worktree
+ * - other project            → print `cd <path> && wave --restore <id>`,
+ *                              copy it to the clipboard, and exit
+ */
+function SessionSelectorFlow({
+  currentWorkdir,
+  worktreePaths,
+  onDone,
+}: {
+  currentWorkdir: string;
+  worktreePaths: string[];
+  onDone: (result: SessionSelectorResult | null) => void;
+}): React.ReactNode {
+  const [showAllProjects, setShowAllProjects] = useState(false);
+  const [showAllWorktrees, setShowAllWorktrees] = useState(false);
+  const [sessions, setSessions] = useState<SessionItem[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [crossProjectCommand, setCrossProjectCommand] = useState<string | null>(
+    null,
+  );
+
+  // Mirror of the scope flags for use inside async reload/decision callbacks.
+  const scopeRef = useRef({ showAllProjects: false, showAllWorktrees: false });
+
+  const loadSessions = useCallback(
+    async (allProjects: boolean, allWorktrees: boolean) => {
+      if (allProjects) {
+        return listAllSessions();
+      }
+      if (allWorktrees) {
+        return listAllSessions({ worktreePaths, workdir: currentWorkdir });
+      }
+      return listSessions(currentWorkdir);
+    },
+    [worktreePaths, currentWorkdir],
+  );
+
+  const reload = useCallback(
+    async (allProjects: boolean, allWorktrees: boolean) => {
+      setLoading(true);
+      try {
+        const result = await loadSessions(allProjects, allWorktrees);
+        setSessions(
+          result.map((s) => ({
+            ...s,
+            firstMessage: truncateContent(s.firstMessage || "No content", 80),
+          })),
+        );
+      } finally {
+        setLoading(false);
+      }
+    },
+    [loadSessions],
+  );
+
+  // Initial load: current directory scope
+  useEffect(() => {
+    void reload(false, false);
+  }, [reload]);
+
+  const handleToggleAllProjects = useCallback(
+    (value: boolean) => {
+      scopeRef.current.showAllProjects = value;
+      setShowAllProjects(value);
+      void reload(value, scopeRef.current.showAllWorktrees);
+    },
+    [reload],
+  );
+
+  const handleToggleAllWorktrees = useCallback(
+    (value: boolean) => {
+      scopeRef.current.showAllWorktrees = value;
+      setShowAllWorktrees(value);
+      void reload(scopeRef.current.showAllProjects, value);
+    },
+    [reload],
+  );
+
+  const handleSelect = useCallback(
+    async (sessionId: string) => {
+      const session = sessions.find((s) => s.id === sessionId);
+      if (!session) return;
+
+      const ownership = await resolveSessionOwnership(session, {
+        worktreePaths,
+        currentWorkdir,
+      });
+
+      switch (ownership.kind) {
+        case "current":
+          onDone({ sessionId });
+          return;
+        case "worktree":
+          onDone({ sessionId, resumeWorkdir: ownership.resumeWorkdir });
+          return;
+        case "cross-project":
+          // Different project — show the cd command instead of resuming in place
+          await setClipboardText(ownership.command);
+          setCrossProjectCommand(ownership.command);
+          return;
+      }
+    },
+    [sessions, worktreePaths, currentWorkdir, onDone],
+  );
+
+  if (crossProjectCommand) {
+    return (
+      <CrossProjectMessage
+        command={crossProjectCommand}
+        onExit={() => onDone(null)}
+      />
+    );
+  }
+
+  if (loading) {
+    return (
+      <Box>
+        <Text dimColor>Loading conversations…</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <Box padding={1}>
+      <SessionSelector
+        sessions={sessions}
+        worktreePaths={worktreePaths}
+        showProjectPath={showAllProjects || showAllWorktrees}
+        onSelect={(id) => void handleSelect(id)}
+        onCancel={() => onDone(null)}
+        onToggleAllProjects={handleToggleAllProjects}
+        onToggleAllWorktrees={handleToggleAllWorktrees}
+      />
+    </Box>
+  );
+}
+
+/**
+ * Cross-project message auto-exits after a short delay (mirrors Claude Code's
+ * resume picker, which prints the cd command and exits).
+ */
+function CrossProjectMessage({
+  command,
+  onExit,
+}: {
+  command: string;
+  onExit: () => void;
+}): React.ReactNode {
+  useEffect(() => {
+    const timer = setTimeout(onExit, 100);
+    return () => clearTimeout(timer);
+  }, [onExit]);
+
+  return (
+    <Box flexDirection="column" gap={1}>
+      <Text>This conversation is from a different directory.</Text>
+      <Box flexDirection="column">
+        <Text>To resume, run:</Text>
+        <Text> {command}</Text>
+      </Box>
+      <Text dimColor>(Command copied to clipboard)</Text>
+    </Box>
+  );
+}
 
 export async function startSessionSelectorCli({
   workdir,
+  worktreePaths = [],
 }: {
   workdir?: string;
-} = {}): Promise<string | null> {
+  worktreePaths?: string[];
+} = {}): Promise<SessionSelectorResult | null> {
   const currentWorkdir = workdir || process.cwd();
-  const sessions = await listSessions(currentWorkdir);
-
-  if (sessions.length === 0) {
-    console.log(`No sessions found for workdir: ${currentWorkdir}`);
-    return null;
-  }
-
-  const sessionsWithContent = sessions.map((s) => ({
-    ...s,
-    firstMessage: truncateContent(s.firstMessage || "No content", 80),
-  }));
 
   return new Promise((resolve) => {
     const { unmount } = render(
-      <Box padding={1}>
-        <SessionSelector
-          sessions={sessionsWithContent}
-          onSelect={(sessionId) => {
-            unmount();
-            resolve(sessionId);
-          }}
-          onCancel={() => {
-            unmount();
-            resolve(null);
-          }}
-        />
-      </Box>,
+      <SessionSelectorFlow
+        currentWorkdir={currentWorkdir}
+        worktreePaths={worktreePaths}
+        onDone={(result) => {
+          unmount();
+          resolve(result);
+        }}
+      />,
     );
   });
 }

package/src/stdio/agentBridge.ts

@@ -375,7 +375,12 @@ export class AgentBridge {
         );
       case "removeWorktree":
         return this.removeWorktreeSession(
-          p as unknown as { path: string; branch: string; repoRoot: string },
+          p as unknown as {
+            path: string;
+            branch: string;
+            repoRoot: string;
+            hookBased?: boolean;
+          },
         );
 
       default:
@@ -615,6 +620,7 @@ export class AgentBridge {
     repoRoot: string;
     baseBranch: string;
     isNew: boolean;
+    hookBased: boolean;
   }> {
     if (!params.workdir) {
       throw new RpcError(PROTOCOL_INTERNAL_ERROR, "workdir is required");
@@ -631,6 +637,7 @@ export class AgentBridge {
         repoRoot: session.repoRoot,
         baseBranch: params.baseBranch ?? getDefaultRemoteBranch(params.workdir),
         isNew: session.isNew,
+        hookBased: session.hookBased ?? false,
       };
     } catch (e) {
       throw new RpcError(PROTOCOL_INTERNAL_ERROR, (e as Error).message);
@@ -641,31 +648,24 @@ export class AgentBridge {
     path: string;
     branch: string;
     repoRoot: string;
+    hookBased?: boolean;
   }): 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;
+    // Hook-based worktrees are owned by the WorktreeRemove hook; the git-root
+    // containment check does not apply to them.
+    if (!params.hookBased) {
+      // 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);
       }
     }
 
     // removeWorktree is best-effort/idempotent: already-removed worktrees or
-    // branches only log, never throw.
+    // branches only log, never throw. Hook-based worktrees go through the
+    // WorktreeRemove hook inside removeWorktree.
     await removeWorktree({
       name: "",
       path: params.path,
@@ -674,6 +674,7 @@ export class AgentBridge {
       hasUncommittedChanges: false,
       hasNewCommits: false,
       isNew: false,
+      hookBased: params.hookBased,
     });
     return { ok: true };
   }

package/src/stdio/daemonServer.ts

@@ -104,7 +104,9 @@ export class DaemonServer {
           probe.once("connect", () => {
             probe.destroy();
             reject(
-              new Error(`另一个 wave daemon 已在 ${this.socketPath} 监听`),
+              new Error(
+                `Another wave daemon is already listening on ${this.socketPath}`,
+              ),
             );
           });
           probe.once("error", (err: NodeJS.ErrnoException) => {

package/src/stdio/jsonRpcConnection.ts

@@ -22,15 +22,28 @@ import {
   isNotification,
 } from "./protocol.js";
 
+export interface JsonRpcConnectionOptions {
+  /** Called when the input stream reaches EOF (parent closed the pipe). Only
+   * stdio mode passes it — it must exit the process when its client dies;
+   * daemon mode never passes it (a detached client must not kill the daemon,
+   * see daemonServer.ts). */
+  onClose?: () => void;
+}
+
 export class JsonRpcConnection {
   private rl: readline.Interface | undefined;
   private started = false;
+  private stoppedByOwner = false;
+  private onClose?: () => void;
 
   constructor(
     private input: Readable,
     private output: Writable,
     private bridge: AgentBridge,
-  ) {}
+    options: JsonRpcConnectionOptions = {},
+  ) {
+    this.onClose = options.onClose;
+  }
 
   start(): void {
     if (this.started) return;
@@ -58,10 +71,15 @@ export class JsonRpcConnection {
 
     this.rl.on("close", () => {
       this.started = false;
+      // stdin EOF from the owning client — not a deliberate stop(). stdio
+      // mode reacts by exiting the process (its parent is gone); daemon mode
+      // has no onClose so a detached client reset never kills the daemon.
+      if (!this.stoppedByOwner) this.onClose?.();
     });
   }
 
   stop(): void {
+    this.stoppedByOwner = true;
     this.rl?.close();
     this.rl = undefined;
     this.started = false;

package/src/stdio/stdioServer.ts

@@ -30,6 +30,7 @@ export class StdioServer {
       options.input ?? process.stdin,
       options.output ?? process.stdout,
       this.bridge,
+      { onClose: () => this.onConnectionClosed() },
     );
   }
 
@@ -45,6 +46,22 @@ export class StdioServer {
     this.conn.stop();
   }
 
+  /**
+   * The owning client closed stdin (EOF) — it's gone, so this process must
+   * follow it. destroyAll() saves each session's transcript and drains
+   * auto-memory first; a timeout bounds it so a stuck agent can't orphan the
+   * exit. This is the real-world "parent died" path: without it the process
+   * lingers forever whenever an agent keeps event-loop handles alive.
+   */
+  private async onConnectionClosed(): Promise<void> {
+    const SHUTDOWN_TIMEOUT_MS = 5_000;
+    await Promise.race([
+      this.bridge.destroyAll(),
+      new Promise((resolve) => setTimeout(resolve, SHUTDOWN_TIMEOUT_MS)),
+    ]);
+    process.exit(0);
+  }
+
   handleLine(line: string): Promise<void> {
     return this.conn.handleLine(line);
   }

package/src/utils/clipboard.ts

@@ -9,6 +9,27 @@ export interface ClipboardImageResult {
   mimeType?: string;
 }
 
+/**
+ * Write text to the system clipboard via the terminal OSC 52 escape sequence.
+ * Works in most modern terminals without external tools (mirrors Claude
+ * Code's setClipboard). Callers must treat a `false` return as "clipboard
+ * unavailable" and still surface the text itself.
+ *
+ * @param text - Text to copy
+ * @returns Promise resolving to true when the sequence was written
+ */
+export async function setClipboardText(text: string): Promise<boolean> {
+  try {
+    process.stdout.write(
+      `\x1b]52;c;${Buffer.from(text, "utf-8").toString("base64")}\x07`,
+    );
+    return true;
+  } catch {
+    // stdout unavailable — clipboard could not be set
+    return false;
+  }
+}
+
 /**
  * Read image from clipboard
  * @returns Promise<ClipboardImageResult> Result containing image path or error information

package/src/utils/highlightUtils.ts

@@ -1,7 +1,52 @@
-import hljs from "highlight.js";
+import hljs from "highlight.js/lib/core";
+import javascript from "highlight.js/lib/languages/javascript";
+import typescript from "highlight.js/lib/languages/typescript";
+import bash from "highlight.js/lib/languages/bash";
+import json from "highlight.js/lib/languages/json";
+import markdown from "highlight.js/lib/languages/markdown";
+import python from "highlight.js/lib/languages/python";
+import yaml from "highlight.js/lib/languages/yaml";
+import xml from "highlight.js/lib/languages/xml";
+import css from "highlight.js/lib/languages/css";
+import sql from "highlight.js/lib/languages/sql";
+import rust from "highlight.js/lib/languages/rust";
+import go from "highlight.js/lib/languages/go";
+import java from "highlight.js/lib/languages/java";
+import cpp from "highlight.js/lib/languages/cpp";
+import c from "highlight.js/lib/languages/c";
+import csharp from "highlight.js/lib/languages/csharp";
+import php from "highlight.js/lib/languages/php";
+import ruby from "highlight.js/lib/languages/ruby";
+import swift from "highlight.js/lib/languages/swift";
+import kotlin from "highlight.js/lib/languages/kotlin";
+import ini from "highlight.js/lib/languages/ini";
 import { parse, Node, HTMLElement, TextNode } from "node-html-parser";
 import chalk from "chalk";
 
+// Register only the languages we auto-detect (the full default import pulls
+// in all 384 languages, ~1.5MB of the bundle).
+hljs.registerLanguage("javascript", javascript);
+hljs.registerLanguage("typescript", typescript);
+hljs.registerLanguage("bash", bash);
+hljs.registerLanguage("json", json);
+hljs.registerLanguage("markdown", markdown);
+hljs.registerLanguage("python", python);
+hljs.registerLanguage("yaml", yaml);
+hljs.registerLanguage("xml", xml);
+hljs.registerLanguage("css", css);
+hljs.registerLanguage("sql", sql);
+hljs.registerLanguage("rust", rust);
+hljs.registerLanguage("go", go);
+hljs.registerLanguage("java", java);
+hljs.registerLanguage("cpp", cpp);
+hljs.registerLanguage("c", c);
+hljs.registerLanguage("csharp", csharp);
+hljs.registerLanguage("php", php);
+hljs.registerLanguage("ruby", ruby);
+hljs.registerLanguage("swift", swift);
+hljs.registerLanguage("kotlin", kotlin);
+hljs.registerLanguage("ini", ini);
+
 const theme: Record<string, (text: string) => string> = {
   "hljs-keyword": chalk.blue,
   "hljs-built_in": chalk.cyan,

package/src/utils/readPackageJson.ts

@@ -0,0 +1,29 @@
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+/**
+ * Reads the nearest package.json by walking up from this module's location.
+ * Works for both the tsc output (dist/<subdir>/...) and the single-file esbuild
+ * bundle (dist/bundle/wave.mjs), whose relative depths differ.
+ */
+export function readNearestPackageJson(): {
+  name: string;
+  version: string;
+  [key: string]: unknown;
+} {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (;;) {
+    const candidate = path.join(dir, "package.json");
+    try {
+      return JSON.parse(readFileSync(candidate, "utf-8"));
+    } catch {
+      // Not here — keep walking up.
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      throw new Error("package.json not found above this module");
+    }
+    dir = parent;
+  }
+}

package/src/utils/streamingText.ts

@@ -0,0 +1,11 @@
+/**
+ * Single-line tail representation of in-flight streaming text: newlines are
+ * flattened to `\n` and, when longer than `maxLen` characters, only the last
+ * `maxLen` characters are kept behind an ellipsis. Shared by the streaming
+ * displays (assistant text, reasoning, tool parameters) and the loading
+ * indicators (compaction / /btw) so the tail style stays consistent.
+ */
+export const streamingTail = (content: string, maxLen = 30): string => {
+  const flat = content.replace(/\n/g, "\\n");
+  return flat.length > maxLen ? `…${flat.slice(-maxLen)}` : flat;
+};