typeclaw 0.1.0

package/src/cli/compose.ts

@@ -0,0 +1,240 @@
+import { defineCommand } from 'citty'
+
+import { composeLogs, composeRestart, composeStart, composeStatus, composeStop, type AgentResult } from '@/compose'
+import { config } from '@/config'
+
+import { formatComposeStatus } from './compose-status'
+import { c, spinner } from './ui'
+
+const startSub = defineCommand({
+  meta: { name: 'start', description: 'start every agent in immediate subdirectories of cwd' },
+  args: {
+    port: {
+      type: 'string',
+      description: 'preferred host port for each agent; collisions fall back to ephemeral per-agent',
+      default: String(config.port),
+    },
+    build: {
+      type: 'boolean',
+      description: 'regenerate each Dockerfile from the template and rebuild',
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const board = makeBoard('Starting agents')
+    const s = spinner()
+    const { agents, results } = await composeStart({
+      rootCwd: process.cwd(),
+      preferredHostPort: Number(args.port),
+      forceBuild: args.build,
+      cliEntry: process.argv[1],
+      onProgress: (event) => {
+        if (event.kind === 'agent-start') {
+          board.add(s, event.name, 'starting')
+        } else {
+          board.set(s, event.name, formatStartDone(event.result))
+        }
+      },
+    })
+    if (agents.length === 0) {
+      console.log(c.dim('No typeclaw agents found in immediate subdirectories of cwd.'))
+      return
+    }
+    const failed = results.reduce((n, r) => (r.ok ? n : n + 1), 0)
+    board.finish(s, results, 'started', failed)
+    if (failed > 0) process.exit(1)
+  },
+})
+
+const stopSub = defineCommand({
+  meta: { name: 'stop', description: 'stop every agent in immediate subdirectories of cwd' },
+  async run() {
+    const board = makeBoard('Stopping agents')
+    const s = spinner()
+    const { agents, results } = await composeStop({
+      rootCwd: process.cwd(),
+      onProgress: (event) => {
+        if (event.kind === 'agent-start') {
+          board.add(s, event.name, 'stopping')
+        } else {
+          board.set(s, event.name, formatStopDone(event.result))
+        }
+      },
+    })
+    if (agents.length === 0) {
+      console.log(c.dim('No typeclaw agents found in immediate subdirectories of cwd.'))
+      return
+    }
+    const failed = results.reduce((n, r) => (r.ok ? n : n + 1), 0)
+    board.finish(s, results, 'stopped', failed)
+    if (failed > 0) process.exit(1)
+  },
+})
+
+const restartSub = defineCommand({
+  meta: { name: 'restart', description: 'stop and relaunch every agent in immediate subdirectories of cwd' },
+  args: {
+    port: {
+      type: 'string',
+      description: 'preferred host port for each agent; collisions fall back to ephemeral per-agent',
+      default: String(config.port),
+    },
+    build: {
+      type: 'boolean',
+      description: 'regenerate each Dockerfile from the template and rebuild',
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const board = makeBoard('Restarting agents')
+    const s = spinner()
+    const { agents, results } = await composeRestart({
+      rootCwd: process.cwd(),
+      preferredHostPort: Number(args.port),
+      forceBuild: args.build,
+      cliEntry: process.argv[1],
+      onProgress: (event) => {
+        if (event.kind === 'agent-start') {
+          board.add(s, event.name, 'stopping')
+        } else if (event.kind === 'agent-stopped') {
+          board.set(s, event.name, c.dim('starting...'))
+        } else {
+          board.set(s, event.name, formatRestartDone(event.result))
+        }
+      },
+    })
+    if (agents.length === 0) {
+      console.log(c.dim('No typeclaw agents found in immediate subdirectories of cwd.'))
+      return
+    }
+    const failed = results.reduce((n, r) => (r.ok ? n : n + 1), 0)
+    board.finish(s, results, 'restarted', failed)
+    if (failed > 0) process.exit(1)
+  },
+})
+
+const statusSub = defineCommand({
+  meta: { name: 'status', description: 'show status of every agent in immediate subdirectories of cwd' },
+  async run() {
+    const result = await composeStatus(process.cwd())
+    const useColor = Boolean(process.stdout.isTTY) && process.env.NO_COLOR === undefined
+    process.stdout.write(`${formatComposeStatus(result, { useColor })}\n`)
+  },
+})
+
+const logsSub = defineCommand({
+  meta: { name: 'logs', description: 'multiplex docker logs for every running agent in immediate subdirectories' },
+  args: {
+    follow: {
+      type: 'boolean',
+      alias: 'f',
+      description: 'stream new log output as it arrives',
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const controller = new AbortController()
+    const onSig = (): void => controller.abort()
+    process.once('SIGINT', onSig)
+    process.once('SIGTERM', onSig)
+    try {
+      if (args.follow) {
+        console.log(c.cyan('Streaming logs for all agents...'))
+      } else {
+        console.log(c.dim('Showing logs for all agents.'))
+      }
+      const result = await composeLogs({ rootCwd: process.cwd(), follow: args.follow, signal: controller.signal })
+      if (result.agents.length === 0) {
+        console.log(c.dim('No typeclaw agents found in immediate subdirectories of cwd.'))
+        return
+      }
+      if (result.exitCode !== 0) process.exit(result.exitCode)
+    } finally {
+      process.off('SIGINT', onSig)
+      process.off('SIGTERM', onSig)
+    }
+  },
+})
+
+export const composeCommand = defineCommand({
+  meta: {
+    name: 'compose',
+    description: 'orchestrate every typeclaw agent in immediate subdirectories of cwd',
+  },
+  subCommands: {
+    start: startSub,
+    stop: stopSub,
+    restart: restartSub,
+    status: statusSub,
+    logs: logsSub,
+  },
+})
+
+// Single clack spinner with a multi-line message body, one line per agent.
+// Concurrent clack spinners can't coexist: each one's render loop writes
+// cursor.to(0) + erase.down() to process.stdout, so they trample each other.
+// Multi-line redraw is safe — clack counts newlines in the previous message
+// and walks the cursor up before erasing (see @clack/prompts spinner.ts).
+type Board = {
+  add: (s: ReturnType<typeof spinner>, name: string, state: string) => void
+  set: (s: ReturnType<typeof spinner>, name: string, state: string) => void
+  finish: <T>(s: ReturnType<typeof spinner>, results: AgentResult<T>[], verb: string, failed: number) => void
+}
+
+function makeBoard(header: string): Board {
+  const order: string[] = []
+  const states = new Map<string, string>()
+  let started = false
+
+  const renderLines = (): string => {
+    const width = order.reduce((w, name) => Math.max(w, name.length), 0)
+    return order.map((name) => `  ${c.bold(name.padEnd(width))}  ${states.get(name) ?? ''}`).join('\n')
+  }
+
+  const paint = (s: ReturnType<typeof spinner>): void => {
+    const body = `${header}\n${renderLines()}`
+    if (!started) {
+      started = true
+      s.start(body)
+    } else {
+      s.message(body)
+    }
+  }
+
+  return {
+    add(s, name, state) {
+      order.push(name)
+      states.set(name, c.dim(`${state}...`))
+      paint(s)
+    },
+    set(s, name, state) {
+      states.set(name, state)
+      paint(s)
+    },
+    finish(s, results, verb, failed) {
+      const total = results.length
+      const ok = total - failed
+      const summary = failed === 0 ? `${verb} ${ok}/${total}` : `${verb} ${ok}/${total} (${failed} failed)`
+      const body = `${failed === 0 ? c.green(summary) : c.red(summary)}\n${renderLines()}`
+      if (failed === 0) s.stop(body)
+      else s.error(body)
+    },
+  }
+}
+
+function formatStartDone<T extends { alreadyRunning?: boolean; hostPort: number }>(result: AgentResult<T>): string {
+  if (!result.ok) return `${c.red('✖')} ${c.red('failed:')} ${result.reason}`
+  const verb = result.data.alreadyRunning ? 'already running' : 'started'
+  return `${c.green('✔')} ${verb} on host port ${c.cyan(String(result.data.hostPort))}`
+}
+
+function formatStopDone<T extends { running: boolean }>(result: AgentResult<T>): string {
+  if (!result.ok) return `${c.red('✖')} ${c.red('failed:')} ${result.reason}`
+  if (result.data.running) return `${c.green('✔')} stopped`
+  return `${c.dim('○')} ${c.dim('not running')}`
+}
+
+function formatRestartDone<T extends { start: { hostPort: number } }>(result: AgentResult<T>): string {
+  if (!result.ok) return `${c.red('✖')} ${c.red('failed:')} ${result.reason}`
+  return `${c.green('✔')} restarted on host port ${c.cyan(String(result.data.start.hostPort))}`
+}

package/src/cli/hostd.ts

@@ -0,0 +1,163 @@
+import { defineCommand } from 'citty'
+
+import { loadConfigSync, validateConfig, type Config, type ValidateConfigResult } from '@/config'
+import { start, stop, type StartOptions, type StartResult, type StopResult } from '@/container'
+import { startDaemon, type DaemonLogEvent, type RestartPreflight } from '@/hostd/daemon'
+import { createPortbrokerManager } from '@/hostd/portbroker-manager'
+import type { SupervisorLogEvent, SupervisorRestart } from '@/hostd/supervisor'
+import { computeSourceVersion, resolveSrcRoot, UNVERSIONED_SENTINEL } from '@/hostd/version'
+
+export const hostdCommand = defineCommand({
+  meta: {
+    name: '_hostd',
+    description: 'internal: host-side typeclaw daemon (do not invoke directly)',
+    hidden: true,
+  },
+  async run() {
+    const cliEntry = process.argv[1] ?? ''
+    const srcRoot = resolveSrcRoot(cliEntry)
+    const version = srcRoot === null ? UNVERSIONED_SENTINEL : await computeSourceVersion({ srcRoot })
+
+    const portbroker = createPortbrokerManager({
+      onLog: (msg) => writeLogLine(msg),
+    })
+
+    const daemon = await startDaemon({
+      onLog: (e) => writeLogLine(formatLog(e)),
+      version,
+      onShutdown: () => process.exit(0),
+      portbroker,
+      restartPreflight: buildHostdRestartPreflight(cliEntry, version),
+      restart: buildHostdRestart(cliEntry, defaultRestartDeps, version),
+    })
+
+    const shutdown = (): void => {
+      void daemon
+        .stop()
+        .then(() => portbroker.drain())
+        .then(() => process.exit(0))
+    }
+    process.on('SIGTERM', shutdown)
+    process.on('SIGINT', shutdown)
+
+    await new Promise<void>(() => {})
+  },
+})
+
+export type HostdRestartDeps = {
+  validateConfig: (cwd: string) => ValidateConfigResult
+  stop: (opts: { cwd: string }) => Promise<StopResult>
+  loadConfigSync: (cwd: string) => Config
+  start: (opts: StartOptions) => Promise<StartResult>
+}
+
+const defaultRestartDeps: HostdRestartDeps = {
+  validateConfig,
+  stop,
+  loadConfigSync,
+  start,
+}
+
+export function buildHostdRestart(
+  cliEntry: string,
+  deps: HostdRestartDeps = defaultRestartDeps,
+  daemonVersion?: string,
+): SupervisorRestart {
+  return async ({ containerName, cwd, build = false }) => {
+    const drift = await detectSourceDrift(cliEntry, daemonVersion)
+    if (drift) return { ok: false, reason: drift }
+
+    const validated = deps.validateConfig(cwd)
+    if (!validated.ok) {
+      return { ok: false, reason: `invalid config for ${containerName}: ${validated.reason}` }
+    }
+    const stopResult = await deps.stop({ cwd })
+    if (!stopResult.ok) return { ok: false, reason: `stop failed: ${stopResult.reason}` }
+
+    const cfg = deps.loadConfigSync(cwd)
+    const startResult = await deps.start({
+      cwd,
+      preferredHostPort: cfg.port,
+      forceBuild: build,
+      cliEntry,
+      reuseCurrentHostDaemon: true,
+    })
+    if (!startResult.ok) return { ok: false, reason: `start failed: ${startResult.reason}` }
+    return { ok: true }
+  }
+}
+
+export function buildHostdRestartPreflight(cliEntry: string, daemonVersion: string): RestartPreflight {
+  return async () => {
+    const drift = await detectSourceDrift(cliEntry, daemonVersion)
+    return drift ? { ok: false, reason: drift } : null
+  }
+}
+
+async function detectSourceDrift(cliEntry: string, daemonVersion: string | undefined): Promise<string | null> {
+  if (!daemonVersion || daemonVersion === UNVERSIONED_SENTINEL) return null
+  const srcRoot = resolveSrcRoot(cliEntry)
+  if (srcRoot === null) return null
+  const currentVersion = await computeSourceVersion({ srcRoot })
+  if (currentVersion === daemonVersion) return null
+  return 'host daemon source has drifted from the current typeclaw source; run `typeclaw restart --build` from the host-stage agent folder so the daemon respawns before rebuilding the Docker image'
+}
+
+function writeLogLine(msg: string): void {
+  console.log(`${new Date().toISOString()} ${msg}`)
+}
+
+function formatLog(event: DaemonLogEvent | SupervisorLogEvent): string {
+  switch (event.kind) {
+    case 'daemon-listening':
+      return `[hostd] listening on ${event.socket}`
+    case 'daemon-http-listening':
+      return `[hostd] HTTP control listening on ${event.host}:${event.port}`
+    case 'daemon-http-port-fallback':
+      return `[hostd] HTTP preferred port ${event.preferred} busy; fell back to ${event.actual} (containers started on ${event.preferred} will see stale TYPECLAW_HOSTD_URL until restarted)`
+    case 'daemon-stopping':
+      return `[hostd] stopping`
+    case 'shutdown-requested':
+      return `[hostd] shutdown requested (version drift); exiting so the next CLI call respawns`
+    case 'register':
+      return `[hostd] registered ${event.containerName}`
+    case 'deregister':
+      return `[hostd] deregistered ${event.containerName} (${event.reason})`
+    case 'registration-skipped':
+      return `[hostd] skipped persisted registration ${event.containerName}: ${event.reason}`
+    case 'restart-scheduled':
+      return `[hostd] restart scheduled for ${event.containerName}${event.build ? ' (with rebuild)' : ''}`
+    case 'restart-completed':
+      return `[hostd] restart completed for ${event.containerName}`
+    case 'restart-failed':
+      return `[hostd] restart failed for ${event.containerName}: ${event.reason}`
+    case 'port-forward-event':
+      return formatPortForwardEvent(event.event)
+    case 'tailscale-serve-event':
+      return formatTailscaleServeEvent(event.event)
+  }
+}
+
+function formatPortForwardEvent(event: import('@/portbroker').PortForwardEvent): string {
+  switch (event.kind) {
+    case 'port-forward-opened':
+      return `[hostd] port-forward opened ${event.containerName}:${event.port} (${event.bindAddr}) → localhost:${event.port}`
+    case 'port-forward-closed':
+      return `[hostd] port-forward closed ${event.containerName}:${event.port} (${event.reason})`
+    case 'port-forward-failed':
+      return `[hostd] port-forward FAILED ${event.containerName}:${event.port} — ${event.reason}`
+  }
+}
+
+function formatTailscaleServeEvent(event: import('@/hostd/tailscale').TailscaleServeEvent): string {
+  switch (event.kind) {
+    case 'tailscale-serve-opened':
+      return `[hostd] tailscale serve opened ${event.containerName}:${event.port}`
+    case 'tailscale-serve-closed':
+      return `[hostd] tailscale serve closed ${event.containerName}:${event.port}`
+    case 'tailscale-serve-skipped':
+      return `[hostd] tailscale serve skipped ${event.containerName}:${event.port} — ${event.reason}`
+    case 'tailscale-serve-failed':
+      return `[hostd] tailscale serve FAILED ${event.containerName}:${event.port} (${event.command}) — ${event.reason}`
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env bun
+
+import { defineCommand, runMain } from 'citty'
+
+const main = defineCommand({
+  meta: {
+    name: 'typeclaw',
+    description: 'TypeClaw agent runtime',
+  },
+  subCommands: {
+    init: () => import('./init').then((m) => m.init),
+    run: () => import('./run').then((m) => m.run),
+    tui: () => import('./tui').then((m) => m.tui),
+    start: () => import('./start').then((m) => m.startCommand),
+    stop: () => import('./stop').then((m) => m.stopCommand),
+    restart: () => import('./restart').then((m) => m.restartCommand),
+    status: () => import('./status').then((m) => m.statusCommand),
+    reload: () => import('./reload').then((m) => m.reload),
+    logs: () => import('./logs').then((m) => m.logsCommand),
+    shell: () => import('./shell').then((m) => m.shellCommand),
+    compose: () => import('./compose').then((m) => m.composeCommand),
+    channel: () => import('./channel').then((m) => m.channelCommand),
+    _hostd: () => import('./hostd').then((m) => m.hostdCommand),
+  },
+})
+
+runMain(main)