webmux 0.23.0 → 0.24.1

package/backend/dist/server.js

@@ -8968,6 +8968,9 @@ class BunGitGateway {
   readWorktreeStatus(cwd) {
     return readGitWorktreeStatus(cwd);
   }
+  readStatus(cwd) {
+    return runGit(["status", "--short", "--untracked-files=all"], cwd);
+  }
   createWorktree(opts) {
     const args = ["worktree", "add"];
     if (opts.mode === "new") {
@@ -9211,6 +9214,18 @@ function toErrorMessage2(error) {
 function stringifyStartupEnvValue(value) {
   return typeof value === "boolean" ? String(value) : value;
 }
+function prefixAgentBranch(agent, branch) {
+  return `${agent}-${branch}`;
+}
+function buildCreateWorktreeTargets(branch, agentSelection) {
+  if (agentSelection === "both") {
+    return [
+      { branch: prefixAgentBranch("claude", branch), agent: "claude" },
+      { branch: prefixAgentBranch("codex", branch), agent: "codex" }
+    ];
+  }
+  return [{ branch, agent: agentSelection }];
+}
 
 class LifecycleError extends Error {
   status;
@@ -9225,114 +9240,47 @@ class LifecycleService {
   constructor(deps) {
     this.deps = deps;
   }
-  async createWorktree(input) {
+  async createWorktrees(input) {
     const mode = input.mode ?? "new";
-    const requestedBaseBranch = input.baseBranch?.trim();
-    if (requestedBaseBranch && !isValidBranchName(requestedBaseBranch)) {
-      throw new LifecycleError("Invalid base branch name", 400);
-    }
-    if (requestedBaseBranch && mode === "existing") {
-      throw new LifecycleError("Base branch is only supported for new worktrees", 400);
+    const agentSelection = input.agent ?? this.deps.config.workspace.defaultAgent;
+    if (agentSelection === "both" && mode === "existing") {
+      throw new LifecycleError("Creating both agents is only supported for new worktrees", 400);
     }
     const branch = await this.resolveBranch(input.branch, input.prompt, mode);
-    if (requestedBaseBranch && requestedBaseBranch === branch) {
-      throw new LifecycleError("Base branch must differ from branch name", 400);
-    }
-    const baseBranch = mode === "new" ? requestedBaseBranch || this.deps.config.workspace.mainBranch : undefined;
-    const branchAvailability = this.resolveBranchAvailability(branch, mode);
-    const { profileName, profile } = this.resolveProfile(input.profile);
-    const agent = this.resolveAgent(input.agent);
-    const worktreePath = this.resolveWorktreePath(branch);
-    const createProgressBase = {
-      branch,
-      ...baseBranch ? { baseBranch } : {},
-      path: worktreePath,
-      profile: profileName,
-      agent
-    };
-    const deleteBranchOnRollback = mode === "new" || branchAvailability.deleteBranchOnRollback;
-    let initialized = null;
+    const targets = buildCreateWorktreeTargets(branch, agentSelection);
+    const createdBranches = [];
     try {
-      await this.reportCreateProgress({
-        ...createProgressBase,
-        phase: "creating_worktree"
-      });
-      await mkdir4(dirname4(worktreePath), { recursive: true });
-      initialized = await createManagedWorktree({
-        repoRoot: this.deps.projectRoot,
-        worktreePath,
-        branch,
-        mode,
-        ...baseBranch ? { baseBranch } : {},
-        ...branchAvailability.startPoint ? { startPoint: branchAvailability.startPoint } : {},
-        profile: profileName,
-        agent,
-        runtime: profile.runtime,
-        startupEnvValues: await this.buildStartupEnvValues(input.envOverrides),
-        allocatedPorts: await this.allocatePorts(),
-        runtimeEnvExtras: { WEBMUX_WORKTREE_PATH: worktreePath },
-        controlUrl: this.controlUrl(),
-        controlToken: await this.deps.getControlToken(),
-        deleteBranchOnRollback
-      }, {
-        git: this.deps.git
-      });
-      await this.reportCreateProgress({
-        ...createProgressBase,
-        phase: "running_post_create_hook"
-      });
-      await this.runLifecycleHook({
-        name: "postCreate",
-        command: this.deps.config.lifecycleHooks.postCreate,
-        meta: initialized.meta,
-        worktreePath
-      });
-      initialized = await this.refreshManagedArtifactsFromMeta({
-        gitDir: initialized.paths.gitDir,
-        meta: initialized.meta,
-        worktreePath
-      });
-      await this.reportCreateProgress({
-        ...createProgressBase,
-        phase: "preparing_runtime"
-      });
-      await ensureAgentRuntimeArtifacts({
-        gitDir: initialized.paths.gitDir,
-        worktreePath
-      });
-      await this.reportCreateProgress({
-        ...createProgressBase,
-        phase: "starting_session"
-      });
-      await this.materializeRuntimeSession({
-        branch,
-        profile,
-        agent,
-        initialized,
-        worktreePath,
-        prompt: input.prompt,
-        launchMode: "fresh"
-      });
-      await this.reportCreateProgress({
-        ...createProgressBase,
-        phase: "reconciling"
-      });
-      await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
-      return {
-        branch,
-        worktreeId: initialized.meta.worktreeId
-      };
+      for (const target of targets) {
+        const created = await this.createResolvedWorktree({
+          ...input,
+          mode,
+          branch: target.branch,
+          agent: target.agent
+        });
+        createdBranches.push(created.branch);
+      }
     } catch (error) {
-      if (initialized) {
-        const cleanupError = await this.cleanupFailedCreate(branch, worktreePath, profile.runtime, deleteBranchOnRollback);
-        if (cleanupError) {
-          throw this.wrapOperationError(new Error(`${toErrorMessage2(error)}; ${cleanupError}`));
-        }
+      const rollbackError = await this.rollbackCreatedWorktrees(createdBranches);
+      if (rollbackError) {
+        throw this.wrapOperationError(new Error(`${toErrorMessage2(error)}; ${rollbackError}`));
       }
       throw this.wrapOperationError(error);
-    } finally {
-      await this.finishCreateProgress(branch);
     }
+    return {
+      primaryBranch: createdBranches[0],
+      branches: createdBranches
+    };
+  }
+  async createWorktree(input) {
+    const mode = input.mode ?? "new";
+    const branch = await this.resolveBranch(input.branch, input.prompt, mode);
+    const agent = this.resolveAgent(input.agent);
+    return await this.createResolvedWorktree({
+      ...input,
+      mode,
+      branch,
+      agent
+    });
   }
   async openWorktree(branch) {
     try {
@@ -9733,6 +9681,123 @@ class LifecycleService {
   async finishCreateProgress(branch) {
     await this.deps.onCreateFinished?.(branch);
   }
+  async rollbackCreatedWorktrees(branches) {
+    const cleanupErrors = [];
+    for (const branch of [...branches].reverse()) {
+      try {
+        await this.removeWorktree(branch);
+      } catch (error) {
+        cleanupErrors.push(`rollback failed for ${branch}: ${toErrorMessage2(error)}`);
+      }
+    }
+    return cleanupErrors.length > 0 ? cleanupErrors.join("; ") : null;
+  }
+  async createResolvedWorktree(input) {
+    const requestedBaseBranch = input.baseBranch?.trim();
+    if (requestedBaseBranch && !isValidBranchName(requestedBaseBranch)) {
+      throw new LifecycleError("Invalid base branch name", 400);
+    }
+    if (requestedBaseBranch && input.mode === "existing") {
+      throw new LifecycleError("Base branch is only supported for new worktrees", 400);
+    }
+    if (requestedBaseBranch && requestedBaseBranch === input.branch) {
+      throw new LifecycleError("Base branch must differ from branch name", 400);
+    }
+    const baseBranch = input.mode === "new" ? requestedBaseBranch || this.deps.config.workspace.mainBranch : undefined;
+    const branchAvailability = this.resolveBranchAvailability(input.branch, input.mode);
+    const { profileName, profile } = this.resolveProfile(input.profile);
+    const worktreePath = this.resolveWorktreePath(input.branch);
+    const createProgressBase = {
+      branch: input.branch,
+      ...baseBranch ? { baseBranch } : {},
+      path: worktreePath,
+      profile: profileName,
+      agent: input.agent
+    };
+    const deleteBranchOnRollback = input.mode === "new" || branchAvailability.deleteBranchOnRollback;
+    let initialized = null;
+    try {
+      await this.reportCreateProgress({
+        ...createProgressBase,
+        phase: "creating_worktree"
+      });
+      await mkdir4(dirname4(worktreePath), { recursive: true });
+      initialized = await createManagedWorktree({
+        repoRoot: this.deps.projectRoot,
+        worktreePath,
+        branch: input.branch,
+        mode: input.mode,
+        ...baseBranch ? { baseBranch } : {},
+        ...branchAvailability.startPoint ? { startPoint: branchAvailability.startPoint } : {},
+        profile: profileName,
+        agent: input.agent,
+        runtime: profile.runtime,
+        startupEnvValues: await this.buildStartupEnvValues(input.envOverrides),
+        allocatedPorts: await this.allocatePorts(),
+        runtimeEnvExtras: { WEBMUX_WORKTREE_PATH: worktreePath },
+        controlUrl: this.controlUrl(),
+        controlToken: await this.deps.getControlToken(),
+        deleteBranchOnRollback
+      }, {
+        git: this.deps.git
+      });
+      await this.reportCreateProgress({
+        ...createProgressBase,
+        phase: "running_post_create_hook"
+      });
+      await this.runLifecycleHook({
+        name: "postCreate",
+        command: this.deps.config.lifecycleHooks.postCreate,
+        meta: initialized.meta,
+        worktreePath
+      });
+      initialized = await this.refreshManagedArtifactsFromMeta({
+        gitDir: initialized.paths.gitDir,
+        meta: initialized.meta,
+        worktreePath
+      });
+      await this.reportCreateProgress({
+        ...createProgressBase,
+        phase: "preparing_runtime"
+      });
+      await ensureAgentRuntimeArtifacts({
+        gitDir: initialized.paths.gitDir,
+        worktreePath
+      });
+      await this.reportCreateProgress({
+        ...createProgressBase,
+        phase: "starting_session"
+      });
+      await this.materializeRuntimeSession({
+        branch: input.branch,
+        profile,
+        agent: input.agent,
+        initialized,
+        worktreePath,
+        prompt: input.prompt,
+        launchMode: "fresh"
+      });
+      await this.reportCreateProgress({
+        ...createProgressBase,
+        phase: "reconciling"
+      });
+      await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
+      return {
+        branch: input.branch,
+        worktreeId: initialized.meta.worktreeId
+      };
+    } catch (error) {
+      if (initialized) {
+        const cleanupError = await this.cleanupFailedCreate(input.branch, worktreePath, profile.runtime, deleteBranchOnRollback);
+        if (cleanupError) {
+          throw this.wrapOperationError(new Error(`${toErrorMessage2(error)}; ${cleanupError}`));
+        }
+      }
+      throw this.wrapOperationError(error);
+    } finally {
+      await this.finishCreateProgress(input.branch);
+    }
+  }
   wrapOperationError(error) {
     if (error instanceof LifecycleError) {
       return error;
@@ -10849,6 +10914,7 @@ class BunPortProbe {
 
 // backend/src/services/auto-name-service.ts
 var MAX_BRANCH_LENGTH = 40;
+var DEFAULT_AUTO_NAME_MODEL = "claude-haiku-4-5-20251001";
 var DEFAULT_SYSTEM_PROMPT = [
   "Generate a concise git branch name from the task description.",
   "Return only the branch name.",
@@ -10899,11 +10965,12 @@ function buildClaudeArgs(model, systemPrompt, prompt) {
     systemPrompt,
     "--output-format",
     "text",
-    "--no-session-persistence"
+    "--no-session-persistence",
+    "--model",
+    model || DEFAULT_AUTO_NAME_MODEL,
+    "--effort",
+    "low"
   ];
-  if (model) {
-    args.push("--model", model);
-  }
   args.push(prompt);
   return args;
 }
@@ -10949,8 +11016,11 @@ class AutoNameService {
       throw new Error(`'${cli}' CLI not found. Install it or check your PATH.`);
     }
     if (result.exitCode !== 0) {
-      const detail = result.stderr.trim() || `exit ${result.exitCode}`;
-      throw new Error(`${cli} failed: ${detail}`);
+      const stderr = result.stderr.trim();
+      const stdout = result.stdout.trim();
+      const output2 = stderr || stdout || `exit ${result.exitCode}`;
+      const command = args.join(" ");
+      throw new Error(`${cli} failed (command: ${command}): ${output2}`);
     }
     const output = result.stdout.trim();
     if (!output) {
@@ -11770,13 +11840,17 @@ async function apiCreateWorktree(req) {
   const baseBranch = typeof body.baseBranch === "string" && body.baseBranch.trim() ? body.baseBranch.trim() : undefined;
   const prompt = typeof body.prompt === "string" && body.prompt.trim() ? body.prompt.trim() : undefined;
   const profile = typeof body.profile === "string" ? body.profile : undefined;
-  const agent = body.agent === "claude" || body.agent === "codex" ? body.agent : undefined;
+  const agent = body.agent === "claude" || body.agent === "codex" || body.agent === "both" ? body.agent : undefined;
   const createLinearTicket = body.createLinearTicket === true;
   const linearTitle = typeof body.linearTitle === "string" && body.linearTitle.trim() ? body.linearTitle.trim() : undefined;
   const mode = body.mode === "new" || body.mode === "existing" ? body.mode : undefined;
+  const agentSelection = agent ?? config.workspace.defaultAgent;
   if (body.mode !== undefined && body.mode !== "new" && body.mode !== "existing") {
     return errorResponse("Invalid worktree create mode", 400);
   }
+  if (body.agent !== undefined && body.agent !== "claude" && body.agent !== "codex" && body.agent !== "both") {
+    return errorResponse("Invalid agent selection", 400);
+  }
   if (baseBranch && !isValidBranchName(baseBranch)) {
     return errorResponse("Invalid base branch name", 400);
   }
@@ -11814,26 +11888,32 @@ async function apiCreateWorktree(req) {
       return errorResponse(linearResult.error, 502);
     }
     resolvedBranch = linearResult.data.branchName;
-    ensureBranchNotCreating(resolvedBranch);
     log.info(`[linear] created ticket ${linearResult.data.identifier} branch=${linearResult.data.branchName} title="${linearResult.data.title.slice(0, 80)}"`);
-  } else if (resolvedBranch) {
-    ensureBranchNotCreating(resolvedBranch);
   }
-  if (resolvedBranch && baseBranch && resolvedBranch === baseBranch) {
-    return errorResponse("Base branch must differ from branch name", 400);
+  if (resolvedBranch) {
+    const targetBranches = buildCreateWorktreeTargets(resolvedBranch, agentSelection).map((target) => target.branch);
+    for (const targetBranch of targetBranches) {
+      ensureBranchNotBusy(targetBranch);
+    }
+    if (baseBranch && targetBranches.some((targetBranch) => targetBranch === baseBranch)) {
+      return errorResponse("Base branch must differ from branch name", 400);
+    }
   }
-  log.info(`[worktree:add] mode=${mode ?? "new"}${resolvedBranch ? ` branch=${resolvedBranch}` : ""}${baseBranch ? ` base=${baseBranch}` : ""}${profile ? ` profile=${profile}` : ""}${agent ? ` agent=${agent}` : ""}${createLinearTicket ? " linearTicket=true" : ""}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}`);
-  const result = await lifecycleService.createWorktree({
+  log.info(`[worktree:add] mode=${mode ?? "new"}${resolvedBranch ? ` branch=${resolvedBranch}` : ""}${baseBranch ? ` base=${baseBranch}` : ""}${profile ? ` profile=${profile}` : ""} agent=${agentSelection}${createLinearTicket ? " linearTicket=true" : ""}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}`);
+  const result = await lifecycleService.createWorktrees({
     mode,
     branch: resolvedBranch,
     baseBranch,
     prompt,
     profile,
-    agent,
+    agent: agentSelection,
     envOverrides
   });
-  log.debug(`[worktree:add] done branch=${result.branch} worktreeId=${result.worktreeId}`);
-  return jsonResponse({ branch: result.branch }, 201);
+  log.debug(`[worktree:add] done branches=${result.branches.join(",")}`);
+  return jsonResponse({
+    primaryBranch: result.primaryBranch,
+    branches: result.branches
+  }, 201);
 }
 async function apiDeleteWorktree(name) {
   return withRemovingBranch(name, async () => {
@@ -11959,11 +12039,13 @@ async function apiGetWorktreeDiff(name) {
   if (!state)
     return errorResponse(`Worktree not found: ${name}`, 404);
   const uncommitted = git.readDiff(state.path);
+  const gitStatus = git.readStatus(state.path);
   const unpushedCommits = git.listUnpushedCommits(state.path);
   const truncated = uncommitted.length > MAX_DIFF_BYTES;
   return jsonResponse({
     uncommitted: truncated ? uncommitted.slice(0, MAX_DIFF_BYTES) : uncommitted,
     uncommittedTruncated: truncated,
+    gitStatus,
     unpushedCommits
   });
 }