@brimveyn/aimux 1.19.6 → 1.20.1

package/src/auto-rename/title-runner.ts

@@ -0,0 +1,96 @@
+import { buildHeadlessInvocation, type HeadlessInvocation } from '../auto-commit/headless-commands'
+
+export type TitleSpawnFn = (
+  invocation: HeadlessInvocation,
+  signal: AbortSignal
+) => Promise<{ stdout: string; exitCode: number } | null>
+
+export function buildTitlePrompt(firstPrompt: string): string {
+  return [
+    'Create a concise tab title for the user request below.',
+    'Return only the title: 2 to 6 words, at most 48 characters, in the same language as the request.',
+    'Do not use quotes, a label, markdown, or ending punctuation.',
+    '',
+    firstPrompt.slice(0, 8_000),
+  ].join('\n')
+}
+
+export function sanitizeGeneratedTitle(raw: string): string | null {
+  const first = raw
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .find(Boolean)
+  if (first == null || first === '') return null
+
+  const unlabelled = first.replace(/^TITLE\s*:\s*/iu, '').replaceAll(/^["'“”‘’]+|["'“”‘’]+$/gu, '')
+  const clean = unlabelled
+    .replaceAll(/\s+/gu, ' ')
+    .replace(/[.!?,;:…]+$/u, '')
+    .trim()
+  const words = clean.split(' ').filter(Boolean)
+  const usesUnspacedScript = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u.test(clean)
+  if (words.length < 2 && !usesUnspacedScript) return null
+
+  let title = words.slice(0, 6).join(' ')
+  if (title.length > 48) {
+    title = title
+      .slice(0, 48)
+      .replace(/\s+\S*$/u, '')
+      .trim()
+  }
+  return title === '' || (title.split(' ').filter(Boolean).length < 2 && !usesUnspacedScript)
+    ? null
+    : title
+}
+
+export async function generateTabTitle(options: {
+  provider: string
+  model?: string
+  firstPrompt: string
+  timeoutMs: number
+  signal: AbortSignal
+  spawn?: TitleSpawnFn
+}): Promise<string | null> {
+  const invocation = buildHeadlessInvocation(
+    options.provider,
+    buildTitlePrompt(options.firstPrompt),
+    options.model
+  )
+  if (!invocation) return null
+
+  const signal = AbortSignal.any([options.signal, AbortSignal.timeout(options.timeoutMs)])
+  try {
+    const result = await (options.spawn ?? defaultSpawn)(invocation, signal)
+    if (!result || result.exitCode !== 0 || signal.aborted) return null
+    return sanitizeGeneratedTitle(result.stdout)
+  } catch {
+    return null
+  }
+}
+
+async function defaultSpawn(
+  invocation: HeadlessInvocation,
+  signal: AbortSignal
+): Promise<{ stdout: string; exitCode: number } | null> {
+  try {
+    const proc = Bun.spawn([invocation.executable, ...invocation.args], {
+      stderr: 'ignore',
+      stdin: 'ignore',
+      stdout: 'pipe',
+    })
+    const abort = () => {
+      try {
+        proc.kill()
+      } catch {
+        // Best effort: the process may already have exited.
+      }
+    }
+    signal.addEventListener('abort', abort, { once: true })
+    const [stdout, exitCode] = await Promise.all([new Response(proc.stdout).text(), proc.exited])
+    signal.removeEventListener('abort', abort)
+    if (signal.aborted) return null
+    return { exitCode: exitCode ?? 1, stdout }
+  } catch {
+    return null
+  }
+}

package/src/cli/client/daemon-client.ts

@@ -135,10 +135,26 @@ export class DaemonClient {
     return this.hello.capabilities
   }
 
+  getAppVersion(): string | null {
+    return this.hello.appVersion ?? null
+  }
+
   getSelectedVersion(): number {
     return this.hello.selectedVersion
   }
 
+  getProcessVersion(): string {
+    return this.hello.processVersion
+  }
+
+  getManagerCapabilities(): readonly string[] {
+    return this.hello.managerCapabilities ?? []
+  }
+
+  getManagerSelectedVersion(): number | null {
+    return this.hello.managerSelectedVersion ?? null
+  }
+
   private async send(request: ClientRequest): Promise<ServerResponse> {
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {

package/src/cli/commands/tab/create.ts

@@ -1,11 +1,16 @@
 import { resolve as resolvePath } from 'node:path'
 
+import type { WorktreeRecord } from '../../../state/types'
+import type { CliContext } from '../../context'
 import type { CliCommand } from '../../registry'
 
 import { loadConfig } from '../../../config'
+import { removeGitWorktree } from '../../../git/worktree'
 import {
   IPC_CAPABILITY_CREATE_TAB_SIZE_FALLBACK,
+  IPC_CAPABILITY_LIST_TABS,
   IPC_CAPABILITY_THIN_ATTACH,
+  IPC_CAPABILITY_WORKER_METADATA,
 } from '../../../ipc/protocol'
 import { createPrefixedId } from '../../../platform/id'
 import {
@@ -14,13 +19,42 @@ import {
   getAllAssistantOptions,
   parseCommand,
 } from '../../../pty/command-registry'
-import { SHARED_FLAGS } from '../../flags'
+import { CliUsageError, SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, writeJson } from '../../output'
 import { createWorkspaceWorktree } from '../worktree/create-core'
 
 const FALLBACK_COLS = 200
 const FALLBACK_ROWS = 60
 
+export interface CreateCliTabOptions {
+  assistantId: string
+  base?: string
+  branch?: string
+  commandOverride?: string
+  cwd?: string
+  effort?: string
+  model?: string
+  newWorktree?: boolean | string
+  title?: string
+  workerName?: string
+  worktreeId?: string
+}
+
+export interface CreateCliTabResult {
+  assistant: string
+  branch: string | null
+  command: string
+  cwd: string | null
+  effort: string | null
+  model: string | null
+  name: string | null
+  path: string | null
+  tabId: string
+  title: string
+  workerName: string | null
+  worktreeId: string | null
+}
+
 /**
  * Resolve the cwd a spawned tab should run in. Precedence: explicit `--cwd`
  * (resolved to absolute) > the resolved worktree's path > undefined (the
@@ -50,6 +84,189 @@ export function resolveAssistantCommand(
   return commandOverride ?? customCommands[option.id] ?? option.command
 }
 
+async function rollbackCreatedWorktree(
+  record: WorktreeRecord,
+  ctx: CliContext,
+  originalError: unknown
+): Promise<never> {
+  const daemon = await ctx.getDaemon()
+  const workspace = ctx.getWorkspace()
+  let rollbackError: unknown
+  try {
+    await removeGitWorktree({
+      force: true,
+      repoPath: record.repoRoot,
+      targetPath: record.path,
+    })
+    await daemon.expectOk('removeWorktreeRecord', {
+      sessionId: workspace.id,
+      worktreeId: record.id,
+    })
+  } catch (error) {
+    rollbackError = error
+  }
+  const original = originalError instanceof Error ? originalError.message : String(originalError)
+  if (rollbackError === undefined) throw originalError
+  const rollback =
+    rollbackError instanceof Error ? rollbackError.message : JSON.stringify(rollbackError)
+  throw new Error(`${original}; rollback failed: ${rollback}`)
+}
+
+/**
+ * Create a tab without writing to stdout. Worker commands compose this helper
+ * with prompt dispatch/await while `tab create` remains a thin compatibility
+ * adapter. All validation and daemon attachment happen before a worktree is
+ * created; any later failure rolls the fresh worktree back.
+ */
+export async function createCliTab(
+  ctx: CliContext,
+  options: CreateCliTabOptions
+): Promise<CreateCliTabResult> {
+  const {
+    assistantId,
+    base,
+    branch,
+    commandOverride,
+    cwd: cwdRaw,
+    effort,
+    model,
+    newWorktree,
+    title: requestedTitle,
+    workerName,
+    worktreeId: requestedWorktreeId,
+  } = options
+  if (assistantId.length === 0) throw new CliUsageError('--assistant is required')
+  if (workerName !== undefined && workerName.trim().length === 0) {
+    throw new CliUsageError('--name must be a non-empty string')
+  }
+  if (commandOverride !== undefined && (model !== undefined || effort !== undefined)) {
+    throw new CliUsageError(
+      '--model / --effort cannot be combined with --command (bake them into --command)'
+    )
+  }
+
+  const createFreshWorktree = newWorktree !== undefined && newWorktree !== false
+  if (createFreshWorktree && requestedWorktreeId !== undefined) {
+    throw new CliUsageError(
+      '--new-worktree creates its own; use --worktree <id> to co-locate instead'
+    )
+  }
+  if (createFreshWorktree && cwdRaw !== undefined) {
+    throw new CliUsageError('--new-worktree sets the cwd to the new worktree; drop --cwd')
+  }
+  if (!createFreshWorktree && (base !== undefined || branch !== undefined)) {
+    throw new CliUsageError(
+      '--base / --branch require --new-worktree (use `worktree create` otherwise)'
+    )
+  }
+
+  // Resolve and validate the complete assistant invocation before touching git.
+  const { customCommands } = loadConfig()
+  const option = getAllAssistantOptions(customCommands).find((entry) => entry.id === assistantId)
+  if (!option) {
+    const known = getAllAssistantOptions(customCommands)
+      .map((entry) => entry.id)
+      .join(', ')
+    throw new CliUsageError(`unknown assistant: ${assistantId} (known: ${known})`)
+  }
+  const command = resolveAssistantCommand(commandOverride, customCommands, option)
+  const { args: baseArgs, executable } = parseCommand(command)
+  const args = [...baseArgs, ...buildAssistantModelArgs(option, { effort, model })]
+  const title = requestedTitle ?? option.label
+  const tabId = createPrefixedId('tab')
+
+  const workspace = ctx.getWorkspace()
+  const daemon = await ctx.getDaemon()
+  if (!daemon.hasCapability(IPC_CAPABILITY_THIN_ATTACH)) {
+    throw new Error(
+      'daemon predates thinAttach capability — restart aimux to pick up the new daemon'
+    )
+  }
+  if (workerName !== undefined && !daemon.hasCapability(IPC_CAPABILITY_WORKER_METADATA)) {
+    throw new Error(
+      'daemon predates workerMetadata capability — restart aimux to use worker commands'
+    )
+  }
+  if (workerName !== undefined) {
+    if (!daemon.hasCapability(IPC_CAPABILITY_LIST_TABS)) {
+      throw new Error('daemon cannot validate worker-name uniqueness — restart aimux')
+    }
+    const existing = await daemon.listTabs(workspace.id)
+    if (existing.tabs.some((tab) => tab.workerName === workerName)) {
+      throw new Error(`worker name already exists in workspace "${workspace.name}": ${workerName}`)
+    }
+  }
+
+  // Attach before creating a worktree so stale daemon/session failures have no
+  // git-side effect.
+  await daemon.attach({ cols: 0, rows: 0, sessionId: workspace.id, thin: true })
+
+  let worktreeId = requestedWorktreeId ?? workspace.activeWorktreeId
+  let worktreeRecord =
+    worktreeId !== undefined
+      ? workspace.worktrees?.find((entry) => entry.id === worktreeId)
+      : undefined
+  if (requestedWorktreeId !== undefined && worktreeRecord === undefined) {
+    const ids = workspace.worktrees?.map((entry) => entry.id).join(', ') ?? '(none)'
+    throw new Error(`unknown worktree id: ${requestedWorktreeId} (known: ${ids})`)
+  }
+
+  let createdWorktree: WorktreeRecord | undefined
+  if (createFreshWorktree) {
+    const worktreeName =
+      typeof newWorktree === 'string' && newWorktree !== ''
+        ? newWorktree
+        : `${assistantId}-${tabId.slice(-6)}`
+    createdWorktree = await createWorkspaceWorktree({
+      base: base ?? 'HEAD',
+      branch: branch ?? `aimux/${worktreeName}`,
+      daemon,
+      name: worktreeName,
+      workspace,
+    })
+    worktreeId = createdWorktree.id
+    worktreeRecord = createdWorktree
+  }
+
+  const cwd = resolveTabCwd(cwdRaw, worktreeRecord)
+  const useFallback = daemon.hasCapability(IPC_CAPABILITY_CREATE_TAB_SIZE_FALLBACK)
+  try {
+    await daemon.expectOk('createTab', {
+      args,
+      assistant: assistantId,
+      autoRenameCandidate: requestedTitle === undefined,
+      cols: useFallback ? 0 : FALLBACK_COLS,
+      command: executable,
+      cwd,
+      rows: useFallback ? 0 : FALLBACK_ROWS,
+      tabId,
+      title,
+      workerName,
+      worktreeId,
+    })
+  } catch (error) {
+    if (createdWorktree !== undefined) {
+      return rollbackCreatedWorktree(createdWorktree, ctx, error)
+    }
+    throw error
+  }
+
+  return {
+    assistant: assistantId,
+    branch: worktreeRecord?.branch ?? null,
+    command: [executable, ...args].join(' '),
+    cwd: cwd ?? null,
+    effort: effort ?? null,
+    model: model ?? null,
+    name: worktreeRecord?.name ?? null,
+    path: worktreeRecord?.path ?? null,
+    tabId,
+    title,
+    workerName: workerName ?? null,
+    worktreeId: worktreeId ?? null,
+  }
+}
+
 export const tabCreate: CliCommand = {
   args: [],
   flags: [
@@ -97,142 +314,37 @@ export const tabCreate: CliCommand = {
   run: async (ctx) => {
     const assistantId = ctx.args.flags.assistant
     if (typeof assistantId !== 'string' || assistantId.length === 0) {
-      throw new Error('--assistant is required')
-    }
-    // Load the workspace's persisted customCommands so CLI-spawned tabs honor
-    // the same assistant commands the UI uses (e.g. skip-permissions flags), and
-    // so purely-custom assistant ids resolve. loadConfig degrades to {} on a
-    // missing/invalid config — no new failure mode.
-    const { customCommands } = loadConfig()
-    const options = getAllAssistantOptions(customCommands)
-    const option = options.find((o) => o.id === assistantId)
-    if (!option) {
-      throw new Error(
-        `unknown assistant: ${assistantId} (known: ${options.map((o) => o.id).join(', ')})`
-      )
+      throw new CliUsageError('--assistant is required')
     }
     const commandOverride =
       typeof ctx.args.flags.command === 'string' ? ctx.args.flags.command : undefined
     const model = typeof ctx.args.flags.model === 'string' ? ctx.args.flags.model : undefined
     const effort = typeof ctx.args.flags.effort === 'string' ? ctx.args.flags.effort : undefined
 
-    // A full `--command` override owns the whole invocation, so `--model` /
-    // `--effort` (which only make sense as additions to the assistant default)
-    // would be ambiguous alongside it — reject rather than silently drop them.
-    if (commandOverride !== undefined && (model !== undefined || effort !== undefined)) {
-      throw new Error(
-        '--model / --effort cannot be combined with --command (bake them into --command)'
-      )
-    }
-
-    const command = resolveAssistantCommand(commandOverride, customCommands, option)
-    const title = typeof ctx.args.flags.title === 'string' ? ctx.args.flags.title : option.label
+    const title = typeof ctx.args.flags.title === 'string' ? ctx.args.flags.title : undefined
     const cwdRaw = typeof ctx.args.flags.cwd === 'string' ? ctx.args.flags.cwd : undefined
-    const tabId = createPrefixedId('tab')
-
-    // `--new-worktree[=<name>]`: create a fresh worktree and run the tab in it.
-    // A bare flag parses as `true` (name derived below); the `=` form names it.
-    const newWorktreeFlag = ctx.args.flags['new-worktree']
-    const newWorktree = newWorktreeFlag !== undefined
+    const newWorktreeRaw = ctx.args.flags['new-worktree']
+    const newWorktreeFlag =
+      typeof newWorktreeRaw === 'string' || typeof newWorktreeRaw === 'boolean'
+        ? newWorktreeRaw
+        : undefined
     const worktreeFlag =
       typeof ctx.args.flags.worktree === 'string' ? ctx.args.flags.worktree : undefined
     const baseFlag = typeof ctx.args.flags.base === 'string' ? ctx.args.flags.base : undefined
     const branchFlag = typeof ctx.args.flags.branch === 'string' ? ctx.args.flags.branch : undefined
-    if (newWorktree && worktreeFlag !== undefined) {
-      throw new Error('--new-worktree creates its own; use --worktree <id> to co-locate instead')
-    }
-    if (newWorktree && cwdRaw !== undefined) {
-      throw new Error('--new-worktree sets the cwd to the new worktree; drop --cwd')
-    }
-    if (!newWorktree && (baseFlag !== undefined || branchFlag !== undefined)) {
-      throw new Error('--base / --branch require --new-worktree (use `worktree create` otherwise)')
-    }
-
-    const workspace = ctx.getWorkspace()
-    const daemon = await ctx.getDaemon()
-
-    if (!daemon.hasCapability(IPC_CAPABILITY_THIN_ATTACH)) {
-      throw new Error(
-        'daemon predates thinAttach capability — restart aimux to pick up the new daemon'
-      )
-    }
-
-    // Resolve the worktree the tab belongs to + its record (for the cwd default
-    // and the output). Three modes: create a fresh one, use an explicit id, or
-    // fall back to the workspace's active worktree.
-    let worktreeId: string | undefined
-    let worktreeRecord: { branch?: string; name?: string; path: string } | undefined
-    if (newWorktree) {
-      const worktreeName =
-        typeof newWorktreeFlag === 'string' && newWorktreeFlag !== ''
-          ? newWorktreeFlag
-          : `${assistantId}-${tabId.slice(-6)}`
-      const record = await createWorkspaceWorktree({
-        base: baseFlag ?? 'HEAD',
-        branch: branchFlag ?? `aimux/${worktreeName}`,
-        daemon,
-        name: worktreeName,
-        workspace,
-      })
-      worktreeId = record.id
-      worktreeRecord = record
-    } else {
-      worktreeId = worktreeFlag ?? workspace.activeWorktreeId
-      if (worktreeFlag !== undefined) {
-        const known = workspace.worktrees?.some((w) => w.id === worktreeFlag) ?? false
-        if (!known) {
-          const ids = workspace.worktrees?.map((w) => w.id).join(', ') ?? '(none)'
-          throw new Error(`unknown worktree id: ${worktreeFlag} (known: ${ids})`)
-        }
-      }
-      worktreeRecord =
-        worktreeId !== undefined ? workspace.worktrees?.find((w) => w.id === worktreeId) : undefined
-    }
-
-    // Default the PTY cwd to the resolved worktree's path so a worker spawned
-    // into a worktree actually runs inside it. An explicit --cwd always wins.
-    const cwd = resolveTabCwd(cwdRaw, worktreeRecord)
-
-    // Thin-attach so we don't clobber the UI's dimensions on the same session.
-    await daemon.attach({ cols: 0, rows: 0, sessionId: workspace.id, thin: true })
-
-    const { args: baseArgs, executable } = parseCommand(command)
-    // Append the model/effort flags to the assistant default. Throws if the
-    // assistant has no control for a requested dimension.
-    const modelArgs = buildAssistantModelArgs(option, { effort, model })
-    const args = [...baseArgs, ...modelArgs]
-
-    // cols/rows = 0 means "fall back to the session's last attached size" on
-    // v11 daemons. Without that capability we have nothing reasonable to put
-    // here (the CLI has no terminal of its own), so use a roomy fallback —
-    // PTYs are reflowable, so 200×60 won't break anything that adapts.
-    const useFallback = daemon.hasCapability(IPC_CAPABILITY_CREATE_TAB_SIZE_FALLBACK)
-    await daemon.expectOk('createTab', {
-      args,
-      assistant: assistantId,
-      cols: useFallback ? 0 : FALLBACK_COLS,
-      command: executable,
-      cwd,
-      rows: useFallback ? 0 : FALLBACK_ROWS,
-      tabId,
-      title,
-      worktreeId,
-    })
-
-    const resolvedCommand = [executable, ...args].join(' ')
-    writeJson({
-      assistant: assistantId,
-      branch: worktreeRecord?.branch ?? null,
-      command: resolvedCommand,
-      cwd: cwd ?? null,
-      effort: effort ?? null,
-      model: model ?? null,
-      name: worktreeRecord?.name ?? null,
-      path: worktreeRecord?.path ?? null,
-      tabId,
+    const result = await createCliTab(ctx, {
+      assistantId,
+      base: baseFlag,
+      branch: branchFlag,
+      commandOverride,
+      cwd: cwdRaw,
+      effort,
+      model,
+      newWorktree: newWorktreeFlag,
       title,
-      worktreeId: worktreeId ?? null,
+      worktreeId: worktreeFlag,
     })
+    writeJson(result)
     return EXIT_OK
   },
   summary: 'Create a new tab in the active workspace',

package/src/cli/commands/tab/prompt-io.ts

@@ -6,6 +6,7 @@
 import type { DaemonClient } from '../../client/daemon-client'
 
 import { bracketedPaste, notationToBytes } from '../../chord'
+import { CliUsageError } from '../../flags'
 
 /**
  * Gap between the bracketed-paste write and the trailing carriage return when
@@ -33,7 +34,7 @@ export async function resolvePromptText(
     (present) => present
   ).length
   if (sources !== 1) {
-    throw new Error(
+    throw new CliUsageError(
       'provide exactly one prompt source: --prompt-file <f>, --stdin, or a [text] positional'
     )
   }

package/src/cli/commands/worker/await.ts

@@ -0,0 +1,33 @@
+import type { CliCommand } from '../../registry'
+
+import { SHARED_FLAGS } from '../../flags'
+import { writeJson } from '../../output'
+import { DEFAULT_TIMEOUT_MS } from '../tab/await-turn'
+import {
+  awaitExistingWorker,
+  resolveWorkerTab,
+  workerEnvelope,
+  workerOutcomeExitCode,
+  workerView,
+} from './shared'
+
+export const workerAwait: CliCommand = {
+  args: [{ name: 'worker', required: true }],
+  flags: [
+    ...SHARED_FLAGS,
+    { description: 'overall turn cap in milliseconds', kind: 'number', name: 'timeout' },
+  ],
+  group: 'worker',
+  run: async (ctx) => {
+    const tab = await resolveWorkerTab(ctx, ctx.args.positionals[0] ?? '')
+    const outcome = await awaitExistingWorker(
+      ctx,
+      tab.id,
+      typeof ctx.args.flags.timeout === 'number' ? ctx.args.flags.timeout : DEFAULT_TIMEOUT_MS
+    )
+    writeJson(workerEnvelope(workerView(ctx, tab), outcome))
+    return workerOutcomeExitCode(outcome)
+  },
+  summary: "Await an existing worker's in-flight turn",
+  verb: 'await',
+}