fix: add auto-name timeout fallback (#205)

* fix: add auto-name timeout fallback

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix: tighten auto-name timeout fallback

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: centdix

backend/src/__tests__/auto-name-service.test.ts

@@ -1,4 +1,7 @@
 import { describe, expect, it } from "bun:test";
+import { chmod, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { AutoNameService } from "../services/auto-name-service";
 
 async function getClaudeCliFlags(): Promise<Set<string>> {
@@ -103,6 +106,24 @@ describe("AutoNameService", () => {
     expect(calls[0]).toContain("gpt-4.1");
   });
 
+  it("passes the configured timeout to the spawn implementation", async () => {
+    const timeouts: Array<number | undefined> = [];
+    const service = new AutoNameService({
+      timeoutMs: 1234,
+      spawnImpl: async (_args, options) => {
+        timeouts.push(options?.timeoutMs);
+        return { exitCode: 0, stdout: "test-branch", stderr: "" };
+      },
+    });
+
+    await service.generateBranchName(
+      { provider: "claude" },
+      "Test timeout wiring",
+    );
+
+    expect(timeouts).toEqual([1234]);
+  });
+
   it("omits -m from codex when model is not specified", async () => {
     const { calls, spawnImpl } = fakeSpawn("add-bulk-actions");
     const service = new AutoNameService({ spawnImpl });
@@ -156,6 +177,42 @@ describe("AutoNameService", () => {
     ).rejects.toThrow(/codex failed \(command: .*\): authentication required/);
   });
 
+  it("returns a change-prefixed fallback branch when the real spawn path times out", async () => {
+    const tempDir = await mkdtemp(join(tmpdir(), "webmux-auto-name-"));
+    const claudePath = join(tempDir, "claude");
+    await Bun.write(
+      claudePath,
+      "#!/bin/sh\ntrap '' TERM\nwhile true; do sleep 1; done\n",
+    );
+    await chmod(claudePath, 0o755);
+
+    const originalPath = Bun.env.PATH;
+    const timeoutMs = 50;
+    const deadlineMs = 1_000;
+    Bun.env.PATH = originalPath ? `${tempDir}:${originalPath}` : tempDir;
+    process.env.PATH = Bun.env.PATH;
+
+    try {
+      const startedAt = Date.now();
+      const branch = await Promise.race([
+        new AutoNameService({ timeoutMs }).generateBranchName(
+          { provider: "claude" },
+          "Fix bug",
+        ),
+        Bun.sleep(deadlineMs).then(() => {
+          throw new Error("timed out waiting for auto-name timeout fallback");
+        }),
+      ]);
+
+      expect(Date.now() - startedAt).toBeLessThan(deadlineMs);
+      expect(branch).toMatch(/^change-[a-f0-9]{8}$/);
+    } finally {
+      Bun.env.PATH = originalPath;
+      process.env.PATH = originalPath;
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  });
+
   it("throws on empty output", async () => {
     const { spawnImpl } = fakeSpawn("");
     const service = new AutoNameService({ spawnImpl });

backend/src/lib/branch-name.ts

@@ -0,0 +1,5 @@
+import { randomUUID } from "node:crypto";
+
+export function generateFallbackBranchName(): string {
+  return `change-${randomUUID().slice(0, 8)}`;
+}

backend/src/services/auto-name-service.ts

@@ -1,16 +1,23 @@
 import type { AutoNameConfig } from "../domain/config";
 import { isValidBranchName } from "../domain/policies";
+import { generateFallbackBranchName } from "../lib/branch-name";
+import { log } from "../lib/log";
 
 interface SpawnResult {
   exitCode: number;
   stdout: string;
   stderr: string;
 }
 
-type SpawnLike = (args: string[]) => Promise<SpawnResult>;
+interface SpawnOptions {
+  timeoutMs?: number;
+}
+
+type SpawnLike = (args: string[], options?: SpawnOptions) => Promise<SpawnResult>;
 
 const MAX_BRANCH_LENGTH = 40;
 const DEFAULT_AUTO_NAME_MODEL = "claude-haiku-4-5-20251001";
+const AUTO_NAME_TIMEOUT_MS = 10_000;
 
 const DEFAULT_SYSTEM_PROMPT = [
   "Generate a concise git branch name from the task description.",
@@ -46,17 +53,50 @@ function getSystemPrompt(config: AutoNameConfig): string {
   return config.systemPrompt?.trim() || DEFAULT_SYSTEM_PROMPT;
 }
 
-async function defaultSpawn(args: string[]): Promise<SpawnResult> {
+class AutoNameTimeoutError extends Error {
+  constructor(readonly timeoutMs: number) {
+    super(`Auto-name timed out after ${timeoutMs}ms`);
+  }
+}
+
+async function defaultSpawn(args: string[], options: SpawnOptions = {}): Promise<SpawnResult> {
   const proc = Bun.spawn(args, {
     stdout: "pipe",
     stderr: "pipe",
   });
-  const [stdout, stderr, exitCode] = await Promise.all([
+  const resultPromise = Promise.all([
     new Response(proc.stdout).text(),
     new Response(proc.stderr).text(),
     proc.exited,
-  ]);
-  return { exitCode, stdout, stderr };
+  ]).then(([stdout, stderr, exitCode]) => ({ exitCode, stdout, stderr }));
+
+  if (options.timeoutMs === undefined) {
+    return await resultPromise;
+  }
+
+  return await new Promise<SpawnResult>((resolve, reject) => {
+    let settled = false;
+    const timeoutId = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      try {
+        proc.kill("SIGKILL");
+      } catch {}
+      reject(new AutoNameTimeoutError(options.timeoutMs!));
+    }, options.timeoutMs);
+
+    void resultPromise.then((result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutId);
+      resolve(result);
+    }, (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutId);
+      reject(error);
+    });
+  });
 }
 
 function buildClaudeArgs(model: string | undefined, systemPrompt: string, prompt: string): string[] {
@@ -97,6 +137,7 @@ function buildCodexArgs(model: string | undefined, systemPrompt: string, prompt:
 
 export interface AutoNameServiceDependencies {
   spawnImpl?: SpawnLike;
+  timeoutMs?: number;
 }
 
 export interface AutoNameGenerator {
@@ -105,9 +146,11 @@ export interface AutoNameGenerator {
 
 export class AutoNameService implements AutoNameGenerator {
   private readonly spawnImpl: SpawnLike;
+  private readonly timeoutMs: number;
 
   constructor(deps: AutoNameServiceDependencies = {}) {
     this.spawnImpl = deps.spawnImpl ?? defaultSpawn;
+    this.timeoutMs = deps.timeoutMs ?? AUTO_NAME_TIMEOUT_MS;
   }
 
   async generateBranchName(config: AutoNameConfig, task: string): Promise<string> {
@@ -127,8 +170,13 @@ export class AutoNameService implements AutoNameGenerator {
 
     let result: SpawnResult;
     try {
-      result = await this.spawnImpl(args);
-    } catch {
+      result = await this.spawnImpl(args, { timeoutMs: this.timeoutMs });
+    } catch (error) {
+      if (error instanceof AutoNameTimeoutError) {
+        const fallback = generateFallbackBranchName();
+        log.warn(`[auto-name] ${cli} timed out after ${this.timeoutMs}ms; using fallback branch ${fallback}`);
+        return fallback;
+      }
       throw new Error(`'${cli}' CLI not found. Install it or check your PATH.`);
     }
 

backend/src/services/lifecycle-service.ts

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import { mkdir } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { ensureAgentRuntimeArtifacts } from "../adapters/agent-runtime";
@@ -37,10 +36,7 @@ import {
   type InitializeManagedWorktreeResult,
 } from "./worktree-service";
 import { log } from "../lib/log";
-
-function generateBranchName(): string {
-  return `change-${randomUUID().slice(0, 8)}`;
-}
+import { generateFallbackBranchName } from "../lib/branch-name";
 
 function toErrorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
@@ -335,7 +331,7 @@ export class LifecycleService {
     const explicitBranch = rawBranch?.trim();
     const branch = mode === "existing"
       ? explicitBranch
-      : explicitBranch || await this.generateAutoName(prompt) || generateBranchName();
+      : explicitBranch || await this.generateAutoName(prompt) || generateFallbackBranchName();
     if (!branch) {
       throw new LifecycleError("Existing branch is required", 400);
     }