wave-code 0.19.9 → 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) {
-        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,
@@ -526,6 +528,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({
@@ -684,7 +708,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(),

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

@@ -2,7 +2,11 @@ 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
@@ -19,6 +23,38 @@ 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
@@ -32,6 +68,19 @@ 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"; baseBranch?: string },
 ): Promise<WorktreeSession> {
   const repoRoot = getGitMainRepoRoot(cwd);
   const worktreePath = path.join(repoRoot, ".wave", "worktrees", name);