webmux 0.22.1 → 0.24.0

package/bin/webmux.js

@@ -257,6 +257,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") {
@@ -10762,11 +10765,12 @@ function buildClaudeArgs(model, systemPrompt, prompt) {
     systemPrompt,
     "--output-format",
     "text",
-    "--no-session-persistence"
+    "--no-session-persistence",
+    "--model",
+    model || DEFAULT_AUTO_NAME_MODEL,
+    "--max-tokens",
+    String(AUTO_NAME_MAX_TOKENS)
   ];
-  if (model) {
-    args.push("--model", model);
-  }
   args.push(prompt);
   return args;
 }
@@ -10812,8 +10816,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) {
@@ -10822,7 +10829,7 @@ class AutoNameService {
     return normalizeGeneratedBranchName(output);
   }
 }
-var MAX_BRANCH_LENGTH = 40, DEFAULT_SYSTEM_PROMPT;
+var MAX_BRANCH_LENGTH = 40, DEFAULT_AUTO_NAME_MODEL = "claude-haiku-4-5-20251001", AUTO_NAME_MAX_TOKENS = 50, DEFAULT_SYSTEM_PROMPT;
 var init_auto_name_service = __esm(() => {
   init_policies();
   DEFAULT_SYSTEM_PROMPT = [
@@ -11131,7 +11138,7 @@ function buildAgentInvocation(input) {
     if (input.launchMode === "resume") {
       return `codex${yoloFlag2} resume --last`;
     }
-    const promptSuffix2 = input.prompt ? ` ${quoteShell(input.prompt)}` : "";
+    const promptSuffix2 = input.prompt ? ` -- ${quoteShell(input.prompt)}` : "";
     if (input.systemPrompt) {
       return `codex${yoloFlag2} -c ${quoteShell(`developer_instructions=${input.systemPrompt}`)}${promptSuffix2}`;
     }
@@ -11141,7 +11148,7 @@ function buildAgentInvocation(input) {
   if (input.launchMode === "resume") {
     return `claude${yoloFlag} --continue`;
   }
-  const promptSuffix = input.prompt ? ` ${quoteShell(input.prompt)}` : "";
+  const promptSuffix = input.prompt ? ` -- ${quoteShell(input.prompt)}` : "";
   if (input.systemPrompt) {
     return `claude${yoloFlag} --append-system-prompt ${quoteShell(input.systemPrompt)}${promptSuffix}`;
   }
@@ -11425,120 +11432,65 @@ 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 LifecycleService {
   deps;
   constructor(deps2) {
     this.deps = deps2;
   }
-  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(dirname5(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 {
@@ -11939,6 +11891,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(dirname5(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;
@@ -12461,6 +12530,7 @@ function createWebmuxRuntime(options = {}) {
     autoName,
     onCreateProgress: (progress) => {
       worktreeCreationTracker.set(progress);
+      options.onCreateProgress?.(progress);
     },
     onCreateFinished: (branch) => {
       worktreeCreationTracker.clear(branch);
@@ -12811,8 +12881,14 @@ async function runWorktreeCommand(context, deps2 = {}) {
       }
       const runtime2 = createRuntime({
         projectDir: context.projectDir,
-        port: context.port
+        port: context.port,
+        onCreateProgress: (progress) => {
+          stdout(PHASE_LABELS[progress.phase] ?? progress.phase);
+        }
       });
+      if (!parsed.input.branch && parsed.input.prompt && runtime2.config.autoName) {
+        stdout("Generating branch name...");
+      }
       const result = await runtime2.lifecycleService.createWorktree(parsed.input);
       stdout(`Created worktree ${result.branch}`);
       if (!parsed.detach) {
@@ -12925,13 +13001,20 @@ async function runWorktreeCommand(context, deps2 = {}) {
     return 1;
   }
 }
-var CommandUsageError;
+var PHASE_LABELS, CommandUsageError;
 var init_worktree_commands = __esm(() => {
   init_dist2();
   init_fs();
   init_tmux();
   init_policies();
   init_runtime();
+  PHASE_LABELS = {
+    creating_worktree: "Creating worktree",
+    running_post_create_hook: "Running post-create hook",
+    preparing_runtime: "Preparing runtime",
+    starting_session: "Starting session",
+    reconciling: "Reconciling"
+  };
   CommandUsageError = class CommandUsageError extends Error {
   };
 });
@@ -12943,7 +13026,7 @@ import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "webmux",
-  version: "0.22.1",
+  version: "0.24.0",
   description: "Web dashboard for workmux \u2014 browser UI with embedded terminals, PR monitoring, and CI integration",
   type: "module",
   repository: {