webmux 0.10.1 → 0.11.0

package/bin/webmux.js

@@ -1768,7 +1768,7 @@ Description=webmux dashboard \u2014 ${config.projectName}
 
 [Service]
 Type=simple
-ExecStart=${config.webmuxPath} --port ${config.port}
+ExecStart=${config.webmuxPath} serve --port ${config.port}
 WorkingDirectory=${config.projectDir}
 Restart=on-failure
 RestartSec=5
@@ -1791,6 +1791,7 @@ function generateLaunchdPlist(config) {
   <key>ProgramArguments</key>
   <array>
     <string>${config.webmuxPath}</string>
+    <string>serve</string>
     <string>--port</string>
     <string>${config.port}</string>
   </array>
@@ -9416,10 +9417,12 @@ function parseLifecycleHooks(raw) {
 function parseAutoName(raw) {
   if (!isRecord3(raw))
     return null;
-  if (typeof raw.model !== "string" || !raw.model.trim())
+  const provider = raw.provider;
+  if (provider !== "claude" && provider !== "codex")
     return null;
   return {
-    model: raw.model.trim(),
+    provider,
+    ...typeof raw.model === "string" && raw.model.trim() ? { model: raw.model.trim() } : {},
     ...typeof raw.system_prompt === "string" && raw.system_prompt.trim() ? { systemPrompt: raw.system_prompt.trim() } : {}
   };
 }
@@ -10146,26 +10149,10 @@ class BunPortProbe {
 }
 
 // backend/src/services/auto-name-service.ts
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function buildPrompt(task) {
   return `Task description:
 ${task.trim()}`;
 }
-function parseBranchNamePayload(raw) {
-  if (!isRecord4(raw) || typeof raw.branch_name !== "string") {
-    throw new Error("Auto-name response did not include branch_name");
-  }
-  return raw.branch_name;
-}
-function parseJsonText(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new Error(`Auto-name response was not valid JSON: ${text}`);
-  }
-}
 function normalizeGeneratedBranchName(raw) {
   let branch = raw.trim();
   branch = branch.replace(/^```[\w-]*\s*/, "").replace(/\s*```$/, "");
@@ -10185,251 +10172,89 @@ function normalizeGeneratedBranchName(raw) {
   }
   return branch;
 }
-function resolveAutoNameModel(modelSpec) {
-  const trimmed = modelSpec.trim();
-  const slashIndex = trimmed.indexOf("/");
-  if (slashIndex > 0) {
-    const provider = trimmed.slice(0, slashIndex);
-    const model = trimmed.slice(slashIndex + 1).trim().replace(/^models\//, "");
-    if (!model) {
-      throw new Error(`Invalid auto_name model: ${modelSpec}`);
-    }
-    if (provider === "anthropic" || provider === "google" || provider === "openai") {
-      return { provider, model };
-    }
-    if (provider === "gemini") {
-      return { provider: "google", model };
-    }
-  }
-  if (trimmed.startsWith("claude-")) {
-    return { provider: "anthropic", model: trimmed };
-  }
-  if (trimmed.startsWith("gemini-") || trimmed.startsWith("models/gemini-")) {
-    return { provider: "google", model: trimmed.replace(/^models\//, "") };
-  }
-  if (/^(gpt-|chatgpt-|o\d)/.test(trimmed)) {
-    return { provider: "openai", model: trimmed };
-  }
-  throw new Error(`Unsupported auto_name model provider for ${modelSpec}. Use an anthropic/, gemini/, google/, or openai/ prefix, or a known model name.`);
-}
 function getSystemPrompt(config) {
   return config.systemPrompt?.trim() || DEFAULT_SYSTEM_PROMPT;
 }
-function extractAnthropicText(raw) {
-  if (!isRecord4(raw) || !Array.isArray(raw.content))
-    return null;
-  for (const item of raw.content) {
-    if (!isRecord4(item))
-      continue;
-    if (item.type === "text" && typeof item.text === "string" && item.text.trim()) {
-      return item.text;
-    }
-  }
-  return null;
+async function defaultSpawn(args) {
+  const proc = Bun.spawn(args, {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited
+  ]);
+  return { exitCode, stdout, stderr };
 }
-function extractGoogleText(raw) {
-  if (!isRecord4(raw) || !Array.isArray(raw.candidates))
-    return null;
-  for (const candidate of raw.candidates) {
-    if (!isRecord4(candidate) || !isRecord4(candidate.content) || !Array.isArray(candidate.content.parts))
-      continue;
-    for (const part of candidate.content.parts) {
-      if (isRecord4(part) && typeof part.text === "string" && part.text.trim()) {
-        return part.text;
-      }
-    }
+function buildClaudeArgs(model, systemPrompt, prompt) {
+  const args = [
+    "claude",
+    "-p",
+    "--system-prompt",
+    systemPrompt,
+    "--output-format",
+    "text",
+    "--no-session-persistence"
+  ];
+  if (model) {
+    args.push("--model", model);
   }
-  return null;
+  args.push(prompt);
+  return args;
 }
-function extractOpenAiText(raw) {
-  if (!isRecord4(raw))
-    return null;
-  if (typeof raw.output_text === "string" && raw.output_text.trim()) {
-    return raw.output_text;
-  }
-  if (!Array.isArray(raw.output))
-    return null;
-  for (const item of raw.output) {
-    if (!isRecord4(item) || !Array.isArray(item.content))
-      continue;
-    for (const content of item.content) {
-      if (!isRecord4(content))
-        continue;
-      if (typeof content.text === "string" && content.text.trim()) {
-        return content.text;
-      }
-    }
-  }
-  return null;
+function escapeTomlString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
 }
-async function readErrorBody(response) {
-  const text = (await response.text()).trim();
-  return text || `HTTP ${response.status}`;
+function buildCodexArgs(model, systemPrompt, prompt) {
+  const args = [
+    "codex",
+    "-c",
+    `developer_instructions="${escapeTomlString(systemPrompt)}"`,
+    "exec",
+    "--ephemeral"
+  ];
+  if (model) {
+    args.push("-m", model);
+  }
+  args.push(prompt);
+  return args;
 }
 
 class AutoNameService {
-  fetchImpl;
-  anthropicApiKey;
-  geminiApiKey;
-  openaiApiKey;
+  spawnImpl;
   constructor(deps2 = {}) {
-    this.fetchImpl = deps2.fetchImpl ?? fetch;
-    this.anthropicApiKey = deps2.anthropicApiKey ?? Bun.env.ANTHROPIC_API_KEY;
-    this.geminiApiKey = deps2.geminiApiKey ?? Bun.env.GEMINI_API_KEY;
-    this.openaiApiKey = deps2.openaiApiKey ?? Bun.env.OPENAI_API_KEY;
+    this.spawnImpl = deps2.spawnImpl ?? defaultSpawn;
   }
   async generateBranchName(config, task) {
     const prompt = task.trim();
     if (!prompt) {
       throw new Error("Auto-name requires a prompt");
     }
-    const resolved = resolveAutoNameModel(config.model);
-    const branchName = resolved.provider === "anthropic" ? await this.generateWithAnthropic(resolved.model, getSystemPrompt(config), prompt) : resolved.provider === "google" ? await this.generateWithGoogle(resolved.model, getSystemPrompt(config), prompt) : await this.generateWithOpenAI(resolved.model, getSystemPrompt(config), prompt);
-    return normalizeGeneratedBranchName(branchName);
-  }
-  async generateWithAnthropic(model, systemPrompt, task) {
-    if (!this.anthropicApiKey) {
-      throw new Error("ANTHROPIC_API_KEY is required for auto_name with Anthropic models");
-    }
-    const response = await this.fetchImpl("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "x-api-key": this.anthropicApiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify({
-        model,
-        system: systemPrompt,
-        max_tokens: 64,
-        messages: [{ role: "user", content: buildPrompt(task) }],
-        output_config: {
-          format: {
-            type: "json_schema",
-            schema: BRANCH_NAME_SCHEMA
-          }
-        }
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Anthropic auto-name request failed: ${await readErrorBody(response)}`);
-    }
-    const json = await response.json();
-    if (isRecord4(json) && json.stop_reason === "refusal") {
-      throw new Error("Anthropic auto-name request was refused");
-    }
-    if (isRecord4(json) && json.stop_reason === "max_tokens") {
-      throw new Error("Anthropic auto-name response hit max_tokens before completing");
-    }
-    const text = extractAnthropicText(json);
-    if (!text) {
-      throw new Error("Anthropic auto-name response did not include text");
-    }
-    return parseBranchNamePayload(parseJsonText(text));
-  }
-  async generateWithGoogle(model, systemPrompt, task) {
-    if (!this.geminiApiKey) {
-      throw new Error("GEMINI_API_KEY is required for auto_name with Gemini models");
-    }
-    const response = await this.fetchImpl(`https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "x-goog-api-key": this.geminiApiKey
-      },
-      body: JSON.stringify({
-        systemInstruction: {
-          parts: [{ text: systemPrompt }]
-        },
-        contents: [
-          {
-            role: "user",
-            parts: [{ text: buildPrompt(task) }]
-          }
-        ],
-        generationConfig: {
-          responseMimeType: "application/json",
-          responseJsonSchema: GEMINI_BRANCH_NAME_SCHEMA
-        }
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Google auto-name request failed: ${await readErrorBody(response)}`);
-    }
-    const json = await response.json();
-    const text = extractGoogleText(json);
-    if (!text) {
-      throw new Error("Google auto-name response did not include text");
-    }
-    return parseBranchNamePayload(parseJsonText(text));
-  }
-  async generateWithOpenAI(model, systemPrompt, task) {
-    if (!this.openaiApiKey) {
-      throw new Error("OPENAI_API_KEY is required for auto_name with OpenAI models");
-    }
-    const response = await this.fetchImpl("https://api.openai.com/v1/responses", {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${this.openaiApiKey}`
-      },
-      body: JSON.stringify({
-        model,
-        input: [
-          { role: "system", content: systemPrompt },
-          { role: "user", content: buildPrompt(task) }
-        ],
-        max_output_tokens: 64,
-        text: {
-          format: {
-            type: "json_schema",
-            name: "branch_name_response",
-            strict: true,
-            schema: BRANCH_NAME_SCHEMA
-          }
-        }
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`OpenAI auto-name request failed: ${await readErrorBody(response)}`);
+    const systemPrompt = getSystemPrompt(config);
+    const userPrompt = buildPrompt(prompt);
+    const args = config.provider === "claude" ? buildClaudeArgs(config.model, systemPrompt, userPrompt) : buildCodexArgs(config.model, systemPrompt, userPrompt);
+    const cli = config.provider === "claude" ? "claude" : "codex";
+    let result;
+    try {
+      result = await this.spawnImpl(args);
+    } catch {
+      throw new Error(`'${cli}' CLI not found. Install it or check your PATH.`);
     }
-    const json = await response.json();
-    if (isRecord4(json) && Array.isArray(json.output)) {
-      for (const item of json.output) {
-        if (!isRecord4(item) || !Array.isArray(item.content))
-          continue;
-        for (const content of item.content) {
-          if (isRecord4(content) && content.type === "refusal" && typeof content.refusal === "string") {
-            throw new Error(`OpenAI auto-name request was refused: ${content.refusal}`);
-          }
-        }
-      }
+    if (result.exitCode !== 0) {
+      const detail = result.stderr.trim() || `exit ${result.exitCode}`;
+      throw new Error(`${cli} failed: ${detail}`);
     }
-    const text = extractOpenAiText(json);
-    if (!text) {
-      throw new Error("OpenAI auto-name response did not include text");
+    const output = result.stdout.trim();
+    if (!output) {
+      throw new Error(`${cli} returned empty output`);
     }
-    return parseBranchNamePayload(parseJsonText(text));
+    return normalizeGeneratedBranchName(output);
   }
 }
-var BRANCH_NAME_SCHEMA, GEMINI_BRANCH_NAME_SCHEMA, DEFAULT_SYSTEM_PROMPT;
+var DEFAULT_SYSTEM_PROMPT;
 var init_auto_name_service = __esm(() => {
   init_policies();
-  BRANCH_NAME_SCHEMA = {
-    type: "object",
-    properties: {
-      branch_name: {
-        type: "string",
-        description: "A lowercase kebab-case git branch name with no prefix"
-      }
-    },
-    required: ["branch_name"],
-    additionalProperties: false
-  };
-  GEMINI_BRANCH_NAME_SCHEMA = {
-    ...BRANCH_NAME_SCHEMA,
-    propertyOrdering: ["branch_name"]
-  };
   DEFAULT_SYSTEM_PROMPT = [
     "Generate a concise git branch name from the task description.",
     "Return only the branch name.",
@@ -10444,7 +10269,7 @@ import { dirname as dirname2, join as join8 } from "path";
 function shellQuote(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
-function isRecord5(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function buildAgentCtlScript() {
@@ -10712,7 +10537,7 @@ async function ensureAgentRuntimeArtifacts(input) {
   await chmod2(artifacts.agentCtlPath, 493);
   const hookSettings = buildClaudeHookSettings(artifacts);
   const hooks = hookSettings.hooks;
-  if (!isRecord5(hooks)) {
+  if (!isRecord4(hooks)) {
     throw new Error("Invalid Claude hook settings");
   }
   await mergeClaudeSettings(artifacts.claudeSettingsPath, hooks);
@@ -12146,25 +11971,28 @@ function usage2() {
 webmux \u2014 Dev dashboard for managing Git worktrees
 
 Usage:
-  webmux              Start the dashboard
+  webmux serve        Start the dashboard server
   webmux init         Interactive project setup
   webmux service      Manage webmux as a system service
+  webmux update       Update webmux to the latest version
   webmux add          Create a worktree using the dashboard lifecycle
   webmux list         List worktrees and their status
   webmux open         Open an existing worktree session
   webmux close        Close a worktree session without removing it
   webmux remove       Remove a worktree
   webmux merge        Merge a worktree into the main branch and remove it
-  webmux --port N     Set port (default: 5111)
-  webmux --debug      Show debug-level logs
-  webmux --help       Show this help message
+
+Options:
+  --port N            Set port (default: 5111)
+  --debug             Show debug-level logs
+  --help              Show this help message
 
 Environment:
   BACKEND_PORT     Same as --port (flag takes precedence)
 `);
 }
 function isRootCommand(value) {
-  return value === "init" || value === "service" || value === "add" || value === "list" || value === "open" || value === "close" || value === "remove" || value === "merge";
+  return value === "serve" || value === "init" || value === "service" || value === "update" || value === "add" || value === "list" || value === "open" || value === "close" || value === "remove" || value === "merge";
 }
 function parseRootArgs(args) {
   let port = parseInt(process.env.BACKEND_PORT || "5111", 10);
@@ -12234,6 +12062,16 @@ if (parsed.command === "service") {
   await service2(parsed.commandArgs);
   process.exit(0);
 }
+if (parsed.command === "update") {
+  console.log("Updating webmux to the latest version...");
+  const proc = Bun.spawn(["bun", "install", "--global", "webmux@latest"], {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const code = await proc.exited;
+  process.exit(code);
+}
 async function loadEnvFile(path) {
   if (!existsSync5(path))
     return;
@@ -12265,6 +12103,10 @@ if (isWorktreeCommand(parsed.command)) {
   });
   process.exit(exitCode);
 }
+if (parsed.command === null) {
+  usage2();
+  process.exit(0);
+}
 if (!existsSync5(resolve6(process.cwd(), ".webmux.yaml"))) {
   console.error("No .webmux.yaml found in this directory.\nRun `webmux init` to set up your project.");
   process.exit(1);