wave-code 0.19.7 → 0.19.9

package/src/stdio/agentBridge.ts

@@ -19,6 +19,9 @@ import {
   Agent,
   type AgentCallbacks,
   type AgentOptions,
+  type BackgroundTask,
+  type BackgroundTaskSummary,
+  type SerializableWorkflowRun,
   type Message,
   type PermissionDecision,
   type PermissionMode,
@@ -31,6 +34,9 @@ import {
   type Scope,
   listSessions,
   searchFiles,
+  generateRandomName,
+  getDefaultRemoteBranch,
+  getMessageContent,
   PromptHistoryManager,
   AuthService,
   PluginCore,
@@ -41,6 +47,8 @@ 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";
 
 export type NotificationEmitter = (
@@ -69,6 +77,8 @@ interface InitializeParams {
   disallowedTools?: string[];
   pluginDirs?: string[];
   mcpServers?: Record<string, McpServerConfig>;
+  worktreeName?: string;
+  isNewWorktree?: boolean;
 }
 
 interface UpdateConfigParams {
@@ -160,6 +170,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":
@@ -247,6 +259,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,
@@ -278,6 +303,38 @@ export class AgentBridge {
           p.workdir as string | undefined,
           sessionId,
         );
+      case "compact":
+        return this.compact(
+          p.customInstructions as string | undefined,
+          sessionId,
+        );
+
+      // ── Background tasks ──
+      case "getBackgroundTaskOutput":
+        return this.getBackgroundTaskOutput(p.taskId as string, sessionId);
+      case "stopBackgroundTask":
+        return this.stopBackgroundTask(p.taskId as string, sessionId);
+
+      case "getWorkflowRuns":
+        return this.getWorkflowRuns(sessionId);
+      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(
@@ -330,6 +387,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),
     };
@@ -381,6 +440,106 @@ 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 }> {
+    // 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;
@@ -431,6 +590,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),
     };
@@ -516,6 +678,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) => m.role === "user" && !m.isMeta && 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);
@@ -555,6 +731,57 @@ export class AgentBridge {
     return entry.agent.getFullMessageThread();
   }
 
+  private async compact(
+    customInstructions: string | undefined,
+    sessionId?: string,
+  ): Promise<null> {
+    const entry = this.requireSession(sessionId);
+    await entry.agent.compact(customInstructions);
+    return null;
+  }
+
+  // ── Background tasks ──
+
+  private getBackgroundTaskOutput(
+    taskId: string,
+    sessionId?: string,
+  ): { output: ReturnType<Agent["getBackgroundTaskOutput"]> } {
+    const entry = this.requireSession(sessionId);
+    return { output: entry.agent.getBackgroundTaskOutput(taskId) };
+  }
+
+  private stopBackgroundTask(
+    taskId: string,
+    sessionId?: string,
+  ): { success: boolean } {
+    const entry = this.requireSession(sessionId);
+    const success = entry.agent.stopBackgroundTask(taskId);
+    return { success };
+  }
+
+  private async getWorkflowRuns(
+    sessionId?: string,
+  ): Promise<{ runs: SerializableWorkflowRun[] }> {
+    const entry = this.requireSession(sessionId);
+    const runs = await entry.agent.getWorkflowRuns();
+    return {
+      runs: runs.map((r) => {
+        const { completionPromise, ...rest } = r;
+        void completionPromise;
+        return rest;
+      }),
+    };
+  }
+
+  private stopWorkflowRun(
+    runId: string,
+    sessionId?: string,
+  ): { success: boolean } {
+    const entry = this.requireSession(sessionId);
+    entry.agent.stopWorkflowRun(runId);
+    return { success: true };
+  }
+
   // ── Permissions ───────────────────────────────────────────────
 
   private async setPermissionMode(
@@ -767,6 +994,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,
@@ -867,6 +1123,25 @@ export class AgentBridge {
       onTasksChange: (tasks: Task[]) => {
         this.emit("tasksChange", { tasks }, ctx.registeredSessionId);
       },
+      onBackgroundTasksChange: (tasks: BackgroundTask[]) => {
+        const summaries: BackgroundTaskSummary[] = tasks.map((t) => ({
+          id: t.id,
+          type: t.type,
+          status: t.status,
+          startTime: t.startTime,
+          endTime: t.endTime,
+          command: t.command,
+          description: t.description,
+          exitCode: t.exitCode,
+          runtime: t.runtime,
+          outputPath: t.outputPath,
+        }));
+        this.emit(
+          "backgroundTasksChange",
+          { tasks: summaries },
+          ctx.registeredSessionId,
+        );
+      },
       onSessionIdChange: (newSessionId: string) => {
         const oldSessionId = ctx.registeredSessionId;
         // Emit with the OLD sessionId so the client's router can deliver it
@@ -922,6 +1197,13 @@ export class AgentBridge {
       onCompactBlockAdded: (content: string) => {
         this.emit("compactBlockAdded", { content }, ctx.registeredSessionId);
       },
+      onCompactionStateChange: (isCompacting: boolean) => {
+        this.emit(
+          "compactionStateChange",
+          { isCompacting },
+          ctx.registeredSessionId,
+        );
+      },
     };
   }
 

package/src/stdio/protocol.ts

@@ -57,6 +57,7 @@ export type RequestMethod =
   | "abortMessage"
   | "clearMessages"
   | "rewindToMessage"
+  | "listRewindCheckpoints"
   | "deleteQueuedMessage"
   | "updateQueuedMessage"
   | "deleteQueuedMessageById"
@@ -86,7 +87,16 @@ export type RequestMethod =
   | "listMarketplaces"
   | "addMarketplace"
   | "removeMarketplace"
-  | "updateMarketplace";
+  | "updateMarketplace"
+  | "compact"
+  | "getBackgroundTaskOutput"
+  | "stopBackgroundTask"
+  | "getWorkflowRuns"
+  | "stopWorkflowRun"
+  // Git / worktree (global — no session required)
+  | "listGitBranches"
+  | "createWorktree"
+  | "removeWorktree";
 
 // ── Client → Server notification methods ────────────────────────
 
@@ -116,7 +126,9 @@ export type ServerNotificationMethod =
   | "notificationMessageAdded"
   | "permissionRequest"
   | "authUrl"
-  | "compactBlockAdded";
+  | "compactBlockAdded"
+  | "compactionStateChange"
+  | "backgroundTasksChange";
 
 // ── Helper: is this a request (has id)? ─────────────────────────
 

package/src/utils/worktree.ts

@@ -1,8 +1,14 @@
-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";
 
+// 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;
   path: string;
@@ -17,13 +23,22 @@ export interface WorktreeSession {
  * 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(name: string, cwd: string): WorktreeSession {
+export async function createWorktree(
+  name: string,
+  cwd: string,
+  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 baseBranch = getDefaultRemoteBranch(cwd);
+  const useHead = options?.baseRef === "head";
+  const resolvedBaseBranch =
+    options?.baseBranch ?? (useHead ? "HEAD" : getDefaultRemoteBranch(cwd));
 
   // Ensure parent directory exists
   const parentDir = path.dirname(worktreePath);
@@ -47,12 +62,11 @@ export function createWorktree(name: string, cwd: string): WorktreeSession {
 
   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"],
       },
     );
 
@@ -66,14 +80,18 @@ export function createWorktree(name: string, cwd: string): WorktreeSession {
       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,
@@ -90,22 +108,28 @@ export function createWorktree(name: string, cwd: string): WorktreeSession {
       }
     }
     if (
-      stderr.includes("not a valid object name") ||
-      stderr.includes("unknown revision")
+      !useHead &&
+      (stderr.includes("not a valid object name") ||
+        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 {
@@ -120,12 +144,11 @@ export function createWorktree(name: string, cwd: string): WorktreeSession {
       } 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 {
@@ -154,37 +177,39 @@ export function createWorktree(name: string, cwd: string): WorktreeSession {
  * 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
@@ -205,9 +230,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