@brimveyn/aimux 1.19.7 → 1.20.2

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

@@ -0,0 +1,153 @@
+import { existsSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+import type { CliCommand } from '../../registry'
+
+import { loadConfig } from '../../../config'
+import { MANAGER_CAPABILITY_WORKER_METADATA } from '../../../ipc/manager-protocol'
+import {
+  IPC_CAPABILITY_LIST_TABS,
+  IPC_CAPABILITY_QUESTION_EVENTS,
+  IPC_CAPABILITY_THIN_ATTACH,
+  IPC_CAPABILITY_TURN_LIFECYCLE,
+  IPC_CAPABILITY_WORKER_METADATA,
+  IPC_CAPABILITY_WORKTREE_LIFECYCLE_EVENTS,
+} from '../../../ipc/protocol'
+import {
+  getAllAssistantOptions,
+  isCommandAvailable,
+  parseCommand,
+} from '../../../pty/command-registry'
+import {
+  findPrimaryWorktree,
+  WORKSPACE_ENV_VAR,
+  workspaceRepoRoot,
+} from '../../client/workspace-resolver'
+import { SHARED_FLAGS } from '../../flags'
+import { EXIT_OK, EXIT_RUNTIME, writeJson } from '../../output'
+import { WORKER_SCHEMA_VERSION } from './shared'
+
+const REQUIRED_DAEMON_CAPABILITIES = [
+  IPC_CAPABILITY_LIST_TABS,
+  IPC_CAPABILITY_QUESTION_EVENTS,
+  IPC_CAPABILITY_THIN_ATTACH,
+  IPC_CAPABILITY_TURN_LIFECYCLE,
+  IPC_CAPABILITY_WORKER_METADATA,
+  IPC_CAPABILITY_WORKTREE_LIFECYCLE_EVENTS,
+] as const
+
+export const workerDoctor: CliCommand = {
+  args: [],
+  flags: SHARED_FLAGS,
+  group: 'worker',
+  run: async (ctx) => {
+    const daemon = await ctx.getDaemon()
+    const workspace = ctx.getWorkspace()
+    const { version } = await import('../../../../package.json')
+    const { customCommands } = loadConfig()
+    const assistants = getAllAssistantOptions(customCommands).map((assistant) => ({
+      available: isCommandAvailable(
+        parseCommand(customCommands[assistant.id] ?? assistant.command).executable
+      ),
+      id: assistant.id,
+      supportsEffort: assistant.model?.buildEffortArgs !== undefined,
+      supportsModel: assistant.model?.buildModelArgs !== undefined,
+    }))
+    const daemonCapabilities = daemon.getCapabilities()
+    const managerCapabilities = daemon.getManagerCapabilities()
+    const missingDaemonCapabilities = REQUIRED_DAEMON_CAPABILITIES.filter(
+      (capability) => !daemonCapabilities.includes(capability)
+    )
+    const missingManagerCapabilities = [MANAGER_CAPABILITY_WORKER_METADATA].filter(
+      (capability) => !managerCapabilities.includes(capability)
+    )
+    const primaryWorktree = findPrimaryWorktree(workspace)
+    const workspaceOrigin = ctx.getWorkspaceOrigin?.() ?? 'active'
+    const availableAssistants = assistants.filter((assistant) => assistant.available)
+    const skillPath = fileURLToPath(
+      new URL('../../../../skills/aimux-orchestrator/', import.meta.url)
+    )
+    const issues: string[] = []
+    if (missingDaemonCapabilities.length > 0) {
+      issues.push(
+        `restart or update aimux; daemon is missing: ${missingDaemonCapabilities.join(', ')}`
+      )
+    }
+    if (missingManagerCapabilities.length > 0) {
+      issues.push(
+        `restart the terminal manager; it is missing: ${missingManagerCapabilities.join(', ')}`
+      )
+    }
+    if (primaryWorktree === undefined) {
+      issues.push('workspace has no primary worktree; default isolated worker runs are unavailable')
+    }
+    if (availableAssistants.length === 0) {
+      issues.push('no configured assistant executable is available on PATH')
+    }
+    if (!existsSync(skillPath)) {
+      issues.push(`packaged orchestrator skill is missing: ${skillPath}`)
+    }
+    // Not an issue — an inferred workspace is the normal interactive case — but
+    // it IS the one resolution mode that can follow the UI to another project
+    // between two calls. An orchestrator dispatching a multi-hour fleet wants to
+    // see this before it starts, not after it reviews diffs from the wrong repo.
+    const warnings: string[] = []
+    if (workspaceOrigin === 'active') {
+      warnings.push(
+        `workspace "${workspace.name}" was inferred from the most recently opened session and follows the UI; pin it with --workspace or ${WORKSPACE_ENV_VAR}`
+      )
+    }
+    const ready = issues.length === 0
+    writeJson({
+      assistants,
+      checks: {
+        assistants: {
+          available: availableAssistants.map((assistant) => assistant.id),
+          ok: availableAssistants.length > 0,
+        },
+        daemonCapabilities: {
+          missing: missingDaemonCapabilities,
+          ok: missingDaemonCapabilities.length === 0,
+        },
+        managerCapabilities: {
+          missing: missingManagerCapabilities,
+          ok: missingManagerCapabilities.length === 0,
+        },
+        skill: { ok: existsSync(skillPath), path: skillPath },
+        workspace: {
+          hasPrimaryWorktree: primaryWorktree !== undefined,
+          name: workspace.name,
+          ok: primaryWorktree !== undefined,
+          /** Repo every fresh worker worktree is cut from — confirm before dispatching. */
+          repoRoot: workspaceRepoRoot(workspace),
+          /** 'flag' | 'env' | 'active'; only 'active' can follow the UI. */
+          source: workspaceOrigin,
+        },
+      },
+      cliVersion: version,
+      daemon: {
+        appVersion: daemon.getAppVersion(),
+        capabilities: daemonCapabilities,
+        managerCapabilities,
+        managerProtocolVersion: daemon.getManagerSelectedVersion(),
+        processVersion: daemon.getProcessVersion(),
+        protocolVersion: daemon.getSelectedVersion(),
+      },
+      issues,
+      ready,
+      schemaVersion: WORKER_SCHEMA_VERSION,
+      skillPath,
+      warnings,
+      workspace: {
+        id: workspace.id,
+        name: workspace.name,
+        projectPath: workspace.projectPath ?? null,
+        repoRoot: workspaceRepoRoot(workspace),
+        source: workspaceOrigin,
+      },
+    })
+    return ready ? EXIT_OK : EXIT_RUNTIME
+  },
+  summary: 'Check worker prerequisites, versions, assistants, and workspace',
+  verb: 'doctor',
+}

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

@@ -0,0 +1,67 @@
+import type { CliCommand } from '../../registry'
+
+import { workspaceIdentity } from '../../client/workspace-resolver'
+import { SHARED_FLAGS } from '../../flags'
+import { EXIT_OK, writeJson } from '../../output'
+import {
+  listNamedWorkerTabs,
+  listWorkerTargets,
+  resolveWorkerTarget,
+  WORKER_SCHEMA_VERSION,
+  workerView,
+} from './shared'
+
+export const workerList: CliCommand = {
+  args: [{ complete: { kind: 'dynamic', source: 'worker' }, name: 'worker' }],
+  flags: [
+    ...SHARED_FLAGS,
+    {
+      description: 'list workers in every catalogued workspace, not just the target one',
+      kind: 'boolean',
+      name: 'all-workspaces',
+    },
+  ],
+  group: 'worker',
+  run: async (ctx) => {
+    const selector = ctx.args.positionals[0]
+
+    // `{"workers":[]}` alone is indistinguishable from "every worker died", and
+    // the natural recovery from that reading is a destructive re-dispatch. Name
+    // the workspace that was queried so an empty fleet is legible as "not here"
+    // rather than "gone", and offer one call that answers "are they really gone?"
+    if (ctx.args.flags['all-workspaces'] === true) {
+      const targets = await listWorkerTargets(ctx)
+      writeJson({
+        schemaVersion: WORKER_SCHEMA_VERSION,
+        workers: targets
+          .filter((target) => selector === undefined || target.tab.workerName === selector)
+          .map((target) => ({
+            ...workerView(target.workspace, target.tab),
+            workspace: workspaceIdentity(target.workspace),
+          })),
+      })
+      return EXIT_OK
+    }
+
+    if (selector !== undefined) {
+      const { tab, workspace } = await resolveWorkerTarget(ctx, selector)
+      writeJson({
+        schemaVersion: WORKER_SCHEMA_VERSION,
+        workers: [workerView(workspace, tab)],
+        workspace: workspaceIdentity(workspace),
+      })
+      return EXIT_OK
+    }
+
+    const workspace = ctx.getWorkspace()
+    const tabs = await listNamedWorkerTabs(ctx, workspace)
+    writeJson({
+      schemaVersion: WORKER_SCHEMA_VERSION,
+      workers: tabs.map((tab) => workerView(workspace, tab)),
+      workspace: workspaceIdentity(workspace),
+    })
+    return EXIT_OK
+  },
+  summary: 'List named workers with liveness and worktree context',
+  verb: 'list',
+}

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

@@ -0,0 +1,74 @@
+import type { CliCommand } from '../../registry'
+
+import { SHARED_FLAGS } from '../../flags'
+import { writeJson } from '../../output'
+import { DEFAULT_TIMEOUT_MS } from '../tab/await-turn'
+import { resolvePromptText } from '../tab/prompt-io'
+import {
+  dispatchWorkerPrompt,
+  resolveWorkerTarget,
+  workerEnvelope,
+  workerOutcomeExitCode,
+  workerView,
+} from './shared'
+
+export const workerPrompt: CliCommand = {
+  args: [
+    { complete: { kind: 'dynamic', source: 'worker' }, name: 'worker', required: true },
+    { complete: { kind: 'none' }, name: 'text' },
+  ],
+  flags: [
+    ...SHARED_FLAGS,
+    {
+      complete: { kind: 'file' },
+      description: 'read the prompt from this file',
+      kind: 'string',
+      name: 'prompt-file',
+    },
+    { description: 'read the prompt from stdin', kind: 'boolean', name: 'stdin' },
+    {
+      description: 'return after prompt uptake instead of turn completion',
+      kind: 'boolean',
+      name: 'detach',
+    },
+    { description: 'overall turn cap in milliseconds', kind: 'number', name: 'timeout' },
+    {
+      description:
+        'milliseconds to wait for the detached submit→working confirmation (default 15000)',
+      kind: 'number',
+      name: 'uptake-timeout',
+    },
+    {
+      description:
+        'clear the composer (<C-u>) before writing, so text typed by a human in the UI cannot be concatenated onto this prompt',
+      kind: 'boolean',
+      name: 'replace',
+    },
+  ],
+  group: 'worker',
+  run: async (ctx) => {
+    const selector = ctx.args.positionals[0] ?? ''
+    const { tab, workspace } = await resolveWorkerTarget(ctx, selector)
+    const promptFile =
+      typeof ctx.args.flags['prompt-file'] === 'string' ? ctx.args.flags['prompt-file'] : undefined
+    const text = await resolvePromptText(
+      promptFile,
+      ctx.args.flags.stdin === true,
+      ctx.args.positionals[1]
+    )
+    const outcome = await dispatchWorkerPrompt(ctx, workspace, tab.id, text, {
+      detach: ctx.args.flags.detach === true,
+      replace: ctx.args.flags.replace === true,
+      timeoutMs:
+        typeof ctx.args.flags.timeout === 'number' ? ctx.args.flags.timeout : DEFAULT_TIMEOUT_MS,
+      uptakeTimeoutMs:
+        typeof ctx.args.flags['uptake-timeout'] === 'number'
+          ? ctx.args.flags['uptake-timeout']
+          : undefined,
+    })
+    writeJson(workerEnvelope(workspace, workerView(workspace, tab), outcome))
+    return workerOutcomeExitCode(outcome)
+  },
+  summary: 'Prompt an existing named worker and await its outcome',
+  verb: 'prompt',
+}

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

@@ -0,0 +1,143 @@
+import type { CliCommand } from '../../registry'
+
+import { CliUsageError, SHARED_FLAGS } from '../../flags'
+import { writeJson } from '../../output'
+import { DEFAULT_TIMEOUT_MS } from '../tab/await-turn'
+import { createCliTab } from '../tab/create'
+import { resolvePromptText } from '../tab/prompt-io'
+import {
+  dispatchWorkerPrompt,
+  validateWorkerName,
+  workerEnvelope,
+  workerOutcomeExitCode,
+  workerView,
+} from './shared'
+
+export const workerRun: CliCommand = {
+  args: [{ complete: { kind: 'none' }, name: 'text' }],
+  flags: [
+    ...SHARED_FLAGS,
+    {
+      complete: { kind: 'none' },
+      description: 'unique workspace-scoped worker name',
+      kind: 'string',
+      name: 'name',
+    },
+    {
+      complete: { kind: 'dynamic', source: 'assistant' },
+      description: 'assistant id (claude, codex, opencode, ...)',
+      kind: 'string',
+      name: 'assistant',
+    },
+    {
+      complete: { kind: 'none' },
+      description: 'model passed through to the assistant',
+      kind: 'string',
+      name: 'model',
+    },
+    {
+      complete: { kind: 'none' },
+      description: 'reasoning effort passed through to the assistant',
+      kind: 'string',
+      name: 'effort',
+    },
+    {
+      complete: { kind: 'file' },
+      description: 'read the prompt from this file',
+      kind: 'string',
+      name: 'prompt-file',
+    },
+    { description: 'read the prompt from stdin', kind: 'boolean', name: 'stdin' },
+    {
+      description: 'return after prompt uptake instead of turn completion',
+      kind: 'boolean',
+      name: 'detach',
+    },
+    { description: 'overall turn cap in milliseconds', kind: 'number', name: 'timeout' },
+    {
+      description:
+        'milliseconds to wait for the detached submit→working confirmation (default 15000)',
+      kind: 'number',
+      name: 'uptake-timeout',
+    },
+    {
+      complete: { kind: 'dynamic', source: 'worktree' },
+      description: 'co-locate in an existing worktree id',
+      kind: 'string',
+      name: 'worktree',
+    },
+    {
+      description: 'run in the workspace active worktree instead of creating one',
+      kind: 'boolean',
+      name: 'no-worktree',
+    },
+    {
+      complete: { kind: 'dynamic', source: 'git-ref' },
+      description: 'base ref for the fresh worktree (default HEAD)',
+      kind: 'string',
+      name: 'base',
+    },
+    {
+      complete: { kind: 'none' },
+      description: 'branch for the fresh worktree (default aimux/<name>)',
+      kind: 'string',
+      name: 'branch',
+    },
+  ],
+  group: 'worker',
+  run: async (ctx) => {
+    const name = typeof ctx.args.flags.name === 'string' ? ctx.args.flags.name : ''
+    const assistant = typeof ctx.args.flags.assistant === 'string' ? ctx.args.flags.assistant : ''
+    validateWorkerName(name)
+    if (assistant === '') throw new CliUsageError('--assistant is required')
+    const worktree =
+      typeof ctx.args.flags.worktree === 'string' ? ctx.args.flags.worktree : undefined
+    const noWorktree = ctx.args.flags['no-worktree'] === true
+    if (worktree !== undefined && noWorktree) {
+      throw new CliUsageError('--worktree and --no-worktree are mutually exclusive')
+    }
+    const promptFile =
+      typeof ctx.args.flags['prompt-file'] === 'string' ? ctx.args.flags['prompt-file'] : undefined
+    const text = await resolvePromptText(
+      promptFile,
+      ctx.args.flags.stdin === true,
+      ctx.args.positionals[0]
+    )
+    // Resolve the target workspace ONCE, up front, and use that record for
+    // every later step. The repo a worktree is cut from comes from this record,
+    // so an orchestrator that omits --workspace at least gets the resolved
+    // identity echoed back in the response instead of having to infer it.
+    const workspace = ctx.getWorkspace()
+    const result = await createCliTab(ctx, {
+      assistantId: assistant,
+      base: typeof ctx.args.flags.base === 'string' ? ctx.args.flags.base : undefined,
+      branch: typeof ctx.args.flags.branch === 'string' ? ctx.args.flags.branch : undefined,
+      effort: typeof ctx.args.flags.effort === 'string' ? ctx.args.flags.effort : undefined,
+      model: typeof ctx.args.flags.model === 'string' ? ctx.args.flags.model : undefined,
+      newWorktree: noWorktree || worktree !== undefined ? undefined : name,
+      title: name,
+      workerName: name,
+      worktreeId: worktree,
+    })
+    const tabs = await (await ctx.getDaemon()).listTabs(workspace.id)
+    const tab = tabs.tabs.find((entry) => entry.id === result.tabId)
+    if (!tab) throw new Error(`created worker disappeared: ${result.tabId}`)
+    const worker = workerView(workspace, tab)
+    const outcome = await dispatchWorkerPrompt(ctx, workspace, result.tabId, text, {
+      // The tab was spawned microseconds ago: its assistant is still booting, so
+      // the prompt must not be written until the TUI is reading keystrokes.
+      awaitFirstPaint: true,
+      detach: ctx.args.flags.detach === true,
+      timeoutMs:
+        typeof ctx.args.flags.timeout === 'number' ? ctx.args.flags.timeout : DEFAULT_TIMEOUT_MS,
+      uptakeTimeoutMs:
+        typeof ctx.args.flags['uptake-timeout'] === 'number'
+          ? ctx.args.flags['uptake-timeout']
+          : undefined,
+    })
+    writeJson(workerEnvelope(workspace, worker, outcome))
+    return workerOutcomeExitCode(outcome)
+  },
+  summary: 'Create a named worker, dispatch a prompt, and await its outcome',
+  verb: 'run',
+}