wave-code 0.19.8 → 1.0.0

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) {
-        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) {
-          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

@@ -34,9 +34,13 @@ import {
   type Scope,
   listSessions,
   searchFiles,
+  generateRandomName,
+  getDefaultRemoteBranch,
+  getMessageContent,
   PromptHistoryManager,
   AuthService,
   PluginCore,
+  validateWorktreeRemovalPath,
   type SlashCommand,
 } from "wave-agent-sdk";
 import {
@@ -44,7 +48,10 @@ import {
   INTERNAL_ERROR as PROTOCOL_INTERNAL_ERROR,
   METHOD_NOT_FOUND as PROTOCOL_METHOD_NOT_FOUND,
 } from "./protocol.js";
+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,
@@ -72,6 +79,8 @@ interface InitializeParams {
   disallowedTools?: string[];
   pluginDirs?: string[];
   mcpServers?: Record<string, McpServerConfig>;
+  worktreeName?: string;
+  isNewWorktree?: boolean;
 }
 
 interface UpdateConfigParams {
@@ -163,6 +172,8 @@ export class AgentBridge {
         return this.clearMessages(sessionId);
       case "rewindToMessage":
         return this.rewindToMessage(p.messageId as string, sessionId);
+      case "listRewindCheckpoints":
+        return this.listRewindCheckpoints(sessionId);
       case "deleteQueuedMessage":
         return this.deleteQueuedMessage(p.index as number, sessionId);
       case "updateQueuedMessage":
@@ -250,6 +261,19 @@ export class AgentBridge {
           p.workdir as string | undefined,
           sessionId,
         );
+      case "getProjectSettings":
+        return this.getProjectSettings(
+          p.workdir as string | undefined,
+          sessionId,
+        );
+      case "setBuiltinPluginEnabled":
+        return this.setBuiltinPluginEnabled(
+          p.pluginId as string,
+          p.enabled as boolean,
+          p.scope as Scope | undefined,
+          p.workdir as string | undefined,
+          sessionId,
+        );
       case "updatePlugin":
         return this.updatePlugin(
           p.pluginId as string,
@@ -298,6 +322,22 @@ export class AgentBridge {
       case "stopWorkflowRun":
         return this.stopWorkflowRun(p.runId as string, sessionId);
 
+      // ── Git / worktree (global — no session required) ──
+      case "listGitBranches":
+        return this.listGitBranches(p.workdir as string | undefined);
+      case "createWorktree":
+        return this.createWorktreeSession(
+          p as unknown as {
+            workdir: string;
+            baseBranch?: string;
+            name?: string;
+          },
+        );
+      case "removeWorktree":
+        return this.removeWorktreeSession(
+          p as unknown as { path: string; branch: string; repoRoot: string },
+        );
+
       default:
         throw new RpcError(
           PROTOCOL_METHOD_NOT_FOUND,
@@ -349,6 +389,8 @@ export class AgentBridge {
       disallowedTools: params.disallowedTools,
       plugins: params.pluginDirs?.map((path) => ({ type: "local", path })),
       mcpServers: params.mcpServers,
+      worktreeName: params.worktreeName,
+      isNewWorktree: params.isNewWorktree,
       canUseTool: (context: ToolPermissionContext) =>
         this.canUseTool(context, ctx),
     };
@@ -400,6 +442,128 @@ export class AgentBridge {
     return { sessions };
   }
 
+  // ── Git / worktree ────────────────────────────────────────────
+
+  private listGitBranches(workdir?: string): {
+    branches: string[];
+    current: string | null;
+  } {
+    if (!workdir) {
+      throw new RpcError(PROTOCOL_INTERNAL_ERROR, "workdir is required");
+    }
+    const gitOpts = {
+      cwd: workdir,
+      encoding: "utf8" as const,
+      stdio: ["ignore", "pipe", "pipe"] as ["ignore", "pipe", "pipe"],
+    };
+    let branchesRaw: string;
+    try {
+      branchesRaw = execFileSync(
+        "git",
+        ["for-each-ref", "--format=%(refname:short)", "refs/heads"],
+        gitOpts,
+      ).trim();
+    } catch {
+      throw new RpcError(
+        PROTOCOL_INTERNAL_ERROR,
+        `Not a git repository (or git unavailable): ${workdir}`,
+      );
+    }
+    const branches = branchesRaw
+      ? branchesRaw
+          .split("\n")
+          .map((b) => b.trim())
+          .filter(Boolean)
+      : [];
+    let current: string | null = null;
+    try {
+      const head = execFileSync(
+        "git",
+        ["rev-parse", "--abbrev-ref", "HEAD"],
+        gitOpts,
+      ).trim();
+      // Detached HEAD prints "HEAD" — treat as no current branch.
+      current = head && head !== "HEAD" ? head : null;
+    } catch {
+      current = null;
+    }
+    return { branches, current };
+  }
+
+  private async createWorktreeSession(params: {
+    workdir: string;
+    baseBranch?: string;
+    name?: string;
+  }): Promise<{
+    name: string;
+    path: string;
+    branch: string;
+    repoRoot: string;
+    baseBranch: string;
+    isNew: boolean;
+  }> {
+    if (!params.workdir) {
+      throw new RpcError(PROTOCOL_INTERNAL_ERROR, "workdir is required");
+    }
+    const name = params.name?.trim() || generateRandomName();
+    try {
+      const session = await createWorktree(name, params.workdir, {
+        baseBranch: params.baseBranch,
+      });
+      return {
+        name: session.name,
+        path: session.path,
+        branch: session.branch,
+        repoRoot: session.repoRoot,
+        baseBranch: params.baseBranch ?? getDefaultRemoteBranch(params.workdir),
+        isNew: session.isNew,
+      };
+    } catch (e) {
+      throw new RpcError(PROTOCOL_INTERNAL_ERROR, (e as Error).message);
+    }
+  }
+
+  private async removeWorktreeSession(params: {
+    path: string;
+    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({
+      name: "",
+      path: params.path,
+      branch: params.branch,
+      repoRoot: params.repoRoot,
+      hasUncommittedChanges: false,
+      hasNewCommits: false,
+      isNew: false,
+    });
+    return { ok: true };
+  }
+
   private getSessionInfo(sessionId?: string): {
     sessionId: string;
     workingDirectory: string;
@@ -450,6 +614,9 @@ export class AgentBridge {
         path: p,
       })),
       mcpServers: entry.storedConfig.mcpServers,
+      // Keep worktree context (permission safety) across recreation, but never
+      // re-fire WorktreeCreate — the hook ran at initial creation.
+      worktreeName: entry.storedConfig.worktreeName,
       canUseTool: (context: ToolPermissionContext) =>
         this.canUseTool(context, ctx),
     };
@@ -535,6 +702,20 @@ export class AgentBridge {
     return { inputContent: textBlock?.content || "" };
   }
 
+  private async listRewindCheckpoints(sessionId?: string): Promise<{
+    checkpoints: Array<{ id: string; content: string }>;
+  }> {
+    const entry = this.requireSession(sessionId);
+    const { messages } = await entry.agent.getFullMessageThread();
+    const checkpoints = messages
+      .filter((m) => isUserCheckpointMessage(m) && m.id)
+      .map((m) => ({
+        id: m.id as string,
+        content: getMessageContent(m).replace(/\s+/g, " ").trim(),
+      }));
+    return { checkpoints };
+  }
+
   private deleteQueuedMessage(index: number, sessionId?: string): null {
     const entry = this.requireSession(sessionId);
     entry.agent.removeQueuedMessage(index);
@@ -837,6 +1018,35 @@ export class AgentBridge {
     );
   }
 
+  private async getProjectSettings(
+    workdir?: string,
+    sessionId?: string,
+  ): Promise<{ enabledPlugins: Record<string, boolean> }> {
+    return {
+      enabledPlugins: this.getPluginCore(
+        workdir,
+        sessionId,
+      ).getMergedEnabledPlugins(),
+    };
+  }
+
+  private async setBuiltinPluginEnabled(
+    pluginId: string,
+    enabled: boolean,
+    scope: Scope | undefined,
+    workdir?: string,
+    sessionId?: string,
+  ): Promise<{ enabledPlugins: Record<string, boolean> }> {
+    const core = this.getPluginCore(workdir, sessionId);
+    const targetScope = scope ?? "project";
+    if (enabled) {
+      await core.enablePlugin(pluginId, targetScope);
+    } else {
+      await core.disablePlugin(pluginId, targetScope);
+    }
+    return { enabledPlugins: core.getMergedEnabledPlugins() };
+  }
+
   private async updatePlugin(
     pluginId: string,
     workdir?: string,

package/src/stdio/protocol.ts

@@ -57,6 +57,7 @@ export type RequestMethod =
   | "abortMessage"
   | "clearMessages"
   | "rewindToMessage"
+  | "listRewindCheckpoints"
   | "deleteQueuedMessage"
   | "updateQueuedMessage"
   | "deleteQueuedMessageById"
@@ -91,7 +92,11 @@ export type RequestMethod =
   | "getBackgroundTaskOutput"
   | "stopBackgroundTask"
   | "getWorkflowRuns"
-  | "stopWorkflowRun";
+  | "stopWorkflowRun"
+  // Git / worktree (global — no session required)
+  | "listGitBranches"
+  | "createWorktree"
+  | "removeWorktree";
 
 // ── Client → Server notification methods ────────────────────────
 

package/src/utils/rewindCheckpoints.ts

@@ -0,0 +1,15 @@
+import type { Message } from "wave-agent-sdk";
+
+/**
+ * 判断一条 user 消息能否作为 /rewind 检查点。
+ * 后台任务通知（task_notification）与 hook 注入的消息（source: "hook"）
+ * 都是系统生成、用户不可见的，不能作为回滚点。
+ * CLI 交互式选择器与 stdio listRewindCheckpoints 共用此判定，避免两处漂移。
+ */
+export function isUserCheckpointMessage(m: Message): boolean {
+  if (m.role !== "user" || m.isMeta) return false;
+  if (m.blocks.some((b) => b.type === "task_notification")) return false;
+  if (m.blocks.some((b) => b.type === "text" && b.source === "hook"))
+    return false;
+  return true;
+}

package/src/utils/worktree.ts

@@ -1,7 +1,17 @@
-import { execFileSync } from "node:child_process";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import * as path from "node:path";
 import * as fs from "node:fs";
-import { getDefaultRemoteBranch, getGitMainRepoRoot } from "wave-agent-sdk";
+import {
+  getDefaultRemoteBranch,
+  getGitMainRepoRoot,
+  performPostCreationSetup,
+} from "wave-agent-sdk";
+
+// Never use execFileSync here: the shared `wave --stdio` process handles all
+// desktop sessions, so a synchronous git call (especially a multi-second
+// recursive worktree delete or a network fetch) freezes every session.
+const execFileAsync = promisify(execFile);
 
 export interface WorktreeSession {
   name: string;
@@ -13,24 +23,71 @@ export interface WorktreeSession {
   isNew: boolean;
 }
 
+// --- Worktree name validation ------------------------------------------------
+
+const VALID_WORKTREE_SLUG_SEGMENT = /^[a-zA-Z0-9._-]+$/;
+const MAX_WORKTREE_SLUG_LENGTH = 64;
+
+/**
+ * Validate a worktree name before any side effects. Names are slash-separated
+ * slugs: every segment must be non-empty and contain only letters, digits,
+ * dots, underscores, and dashes. The total length is capped at 64 characters
+ * and "." / ".." segments are rejected (path traversal protection).
+ * @throws {Error} When the name is not a valid slug
+ */
+export function validateWorktreeSlug(name: string): void {
+  if (name.length > MAX_WORKTREE_SLUG_LENGTH) {
+    throw new Error(
+      `Invalid worktree name: "${name}" must be ${MAX_WORKTREE_SLUG_LENGTH} characters or fewer (got ${name.length})`,
+    );
+  }
+  for (const segment of name.split("/")) {
+    if (segment === "." || segment === "..") {
+      throw new Error(
+        `Invalid worktree name: "${name}" must not contain "." or ".." path segments`,
+      );
+    }
+    if (segment.length === 0 || !VALID_WORKTREE_SLUG_SEGMENT.test(segment)) {
+      throw new Error(
+        `Invalid worktree name: "${name}" each "/"-separated segment must be non-empty and contain only letters, digits, dots, underscores, and dashes`,
+      );
+    }
+  }
+}
+
 /**
  * Create a new git worktree
  * @param name Worktree name
  * @param cwd Current working directory
  * @param options Optional creation options
  * @param options.baseRef "fresh" (default, origin/<default-branch>) | "head" (local HEAD)
+ * @param options.baseBranch Explicit base branch (overrides baseRef)
  * @returns Worktree session details
  */
-export function createWorktree(
+export async function createWorktree(
+  name: string,
+  cwd: string,
+  options?: { baseRef?: "fresh" | "head"; baseBranch?: string },
+): Promise<WorktreeSession> {
+  validateWorktreeSlug(name);
+  const session = await createWorktreeInternal(name, cwd, options);
+  if (session.isNew) {
+    await performPostCreationSetup(session.path, session.repoRoot);
+  }
+  return session;
+}
+
+async function createWorktreeInternal(
   name: string,
   cwd: string,
-  options?: { baseRef?: "fresh" | "head" },
-): WorktreeSession {
+  options?: { baseRef?: "fresh" | "head"; baseBranch?: string },
+): Promise<WorktreeSession> {
   const repoRoot = getGitMainRepoRoot(cwd);
   const worktreePath = path.join(repoRoot, ".wave", "worktrees", name);
   const branchName = `worktree-${name}`;
   const useHead = options?.baseRef === "head";
-  const baseBranch = useHead ? "HEAD" : getDefaultRemoteBranch(cwd);
+  const resolvedBaseBranch =
+    options?.baseBranch ?? (useHead ? "HEAD" : getDefaultRemoteBranch(cwd));
 
   // Ensure parent directory exists
   const parentDir = path.dirname(worktreePath);
@@ -54,12 +111,11 @@ export function createWorktree(
 
   try {
     // Create worktree and branch
-    execFileSync(
+    await execFileAsync(
       "git",
-      ["worktree", "add", "-b", branchName, worktreePath, baseBranch],
+      ["worktree", "add", "-b", branchName, worktreePath, resolvedBaseBranch],
       {
         cwd: repoRoot,
-        stdio: ["ignore", "pipe", "pipe"],
       },
     );
 
@@ -73,14 +129,18 @@ export function createWorktree(
       isNew: true,
     };
   } catch (error: unknown) {
-    const stderr = (error as { stderr?: Buffer }).stderr?.toString() || "";
+    const stderr =
+      (error as { stderr?: Buffer | string }).stderr?.toString() || "";
     if (stderr.includes("already exists")) {
       // If branch already exists, try to add worktree without -b
       try {
-        execFileSync("git", ["worktree", "add", worktreePath, branchName], {
-          cwd: repoRoot,
-          stdio: ["ignore", "pipe", "pipe"],
-        });
+        await execFileAsync(
+          "git",
+          ["worktree", "add", worktreePath, branchName],
+          {
+            cwd: repoRoot,
+          },
+        );
         return {
           name,
           path: worktreePath,
@@ -102,18 +162,23 @@ export function createWorktree(
         stderr.includes("unknown revision"))
     ) {
       // Base branch not fetched yet — try fetching then retrying
-      const branchNameOnly = baseBranch.split("/").pop()!;
+      const branchNameOnly = resolvedBaseBranch.split("/").pop()!;
       try {
-        execFileSync("git", ["fetch", "origin", branchNameOnly], {
+        await execFileAsync("git", ["fetch", "origin", branchNameOnly], {
           cwd: repoRoot,
-          stdio: ["ignore", "pipe", "pipe"],
         });
-        execFileSync(
+        await execFileAsync(
           "git",
-          ["worktree", "add", "-b", branchName, worktreePath, baseBranch],
+          [
+            "worktree",
+            "add",
+            "-b",
+            branchName,
+            worktreePath,
+            resolvedBaseBranch,
+          ],
           {
             cwd: repoRoot,
-            stdio: ["ignore", "pipe", "pipe"],
           },
         );
         return {
@@ -128,12 +193,11 @@ export function createWorktree(
       } catch {
         // Fetch or retry failed — fall back to HEAD
         try {
-          execFileSync(
+          await execFileAsync(
             "git",
             ["worktree", "add", "-b", branchName, worktreePath, "HEAD"],
             {
               cwd: repoRoot,
-              stdio: ["ignore", "pipe", "pipe"],
             },
           );
           return {
@@ -162,37 +226,39 @@ export function createWorktree(
  * Remove a git worktree and its associated branch
  * @param session Worktree session details
  */
-export function removeWorktree(session: WorktreeSession): void {
+export async function removeWorktree(session: WorktreeSession): Promise<void> {
   const repoRoot = session.repoRoot;
 
   try {
     // Get current branch in worktree before removing it
     let currentBranch: string | undefined;
     try {
-      currentBranch = execFileSync(
+      const { stdout } = await execFileAsync(
         "git",
         ["rev-parse", "--abbrev-ref", "HEAD"],
         {
           cwd: session.path,
           encoding: "utf8",
-          stdio: ["ignore", "pipe", "ignore"],
         },
-      ).trim();
+      );
+      currentBranch = stdout.trim();
     } catch {
       // Ignore errors getting current branch
     }
 
     // Remove worktree
-    execFileSync("git", ["worktree", "remove", "--force", session.path], {
-      cwd: repoRoot,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
+    await execFileAsync(
+      "git",
+      ["worktree", "remove", "--force", session.path],
+      {
+        cwd: repoRoot,
+      },
+    );
 
     // Delete original branch
     try {
-      execFileSync("git", ["branch", "-D", session.branch], {
+      await execFileAsync("git", ["branch", "-D", session.branch], {
         cwd: repoRoot,
-        stdio: ["ignore", "pipe", "pipe"],
       });
     } catch {
       // Ignore errors deleting original branch
@@ -213,9 +279,8 @@ export function removeWorktree(session: WorktreeSession): void {
         currentBranch !== "master"
       ) {
         try {
-          execFileSync("git", ["branch", "-D", currentBranch], {
+          await execFileAsync("git", ["branch", "-D", currentBranch], {
             cwd: repoRoot,
-            stdio: ["ignore", "pipe", "pipe"],
           });
         } catch {
           // Ignore errors deleting current branch