typeclaw 0.1.0

package/src/compose/discover.ts

@@ -0,0 +1,43 @@
+import { readdirSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+import { containerNameFromCwd } from '@/container'
+import { isInitialized } from '@/init'
+
+export type AgentEntry = {
+  name: string
+  cwd: string
+  containerName: string
+}
+
+// One-depth scan: lists immediate subdirectories of `rootCwd`, keeps the ones
+// that contain a typeclaw.json, and skips dot-prefixed names (.git, .vscode,
+// node_modules-style hidden dirs are not skipped because they don't match the
+// dot-prefix rule, but they also won't pass the typeclaw.json filter).
+//
+// Returns an empty array when rootCwd doesn't exist or is empty — discovery is
+// not the place to fail; the caller decides what to do with zero agents.
+//
+// Sort by name so output across operations (up/down/ps/restart/logs) is
+// deterministic regardless of filesystem readdir order.
+export function discoverAgents(rootCwd: string): AgentEntry[] {
+  const root = resolve(rootCwd)
+  let entries: { name: string; isDir: boolean }[]
+  try {
+    entries = readdirSync(root, { withFileTypes: true }).map((d) => ({ name: d.name, isDir: d.isDirectory() }))
+  } catch {
+    return []
+  }
+
+  const agents: AgentEntry[] = []
+  for (const entry of entries) {
+    if (!entry.isDir) continue
+    if (entry.name.startsWith('.')) continue
+    const cwd = join(root, entry.name)
+    if (!isInitialized(cwd)) continue
+    agents.push({ name: entry.name, cwd, containerName: containerNameFromCwd(cwd) })
+  }
+
+  agents.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+  return agents
+}

package/src/compose/index.ts

@@ -0,0 +1,25 @@
+export { discoverAgents, type AgentEntry } from './discover'
+export { colorFor, composeLogs, makeLinePrefixer, type ComposeLogsOptions, type ComposeLogsResult } from './logs'
+export { composeStatus, type AgentRuntimeState, type AgentStatusEntry, type ComposeStatusResult } from './status'
+export {
+  composeRestart,
+  type ComposeRestartEvent,
+  type ComposeRestartOptions,
+  type ComposeRestartResult,
+  type RestartData,
+} from './restart'
+export {
+  composeStart,
+  type AgentResult,
+  type ComposeStartEvent,
+  type ComposeStartOptions,
+  type ComposeStartResult,
+  type StartSuccess,
+} from './start'
+export {
+  composeStop,
+  type ComposeStopEvent,
+  type ComposeStopOptions,
+  type ComposeStopResult,
+  type StopSuccess,
+} from './stop'

package/src/compose/logs.ts

@@ -0,0 +1,162 @@
+import { containerExists } from '@/container'
+import { getBun } from '@/container/shared'
+
+import { discoverAgents, type AgentEntry } from './discover'
+
+export type ComposeLogsOptions = {
+  rootCwd: string
+  follow: boolean
+  out?: NodeJS.WritableStream
+  err?: NodeJS.WritableStream
+  signal?: AbortSignal
+}
+
+export type ComposeLogsResult = {
+  agents: AgentEntry[]
+  attached: AgentEntry[]
+  missing: AgentEntry[]
+  exitCode: number
+}
+
+const COLORS = ['36', '33', '32', '35', '34', '31', '96', '93', '92', '95'] as const
+
+export function colorFor(name: string, palette: readonly string[] = COLORS): string {
+  let h = 0
+  for (let i = 0; i < name.length; i++) h = (h * 31 + name.charCodeAt(i)) >>> 0
+  return palette[h % palette.length] ?? '0'
+}
+
+// Stateful chunker that buffers partial lines across chunks: only emits
+// newline-terminated lines (each prefixed with the agent name + bar), and
+// flushes the un-terminated tail on EOF. Without this, interleaved chunks
+// from multiple agents would shred lines mid-character.
+export function makeLinePrefixer(
+  name: string,
+  width: number,
+  color: string,
+  useColor: boolean,
+): { write: (chunk: string) => string; flush: () => string } {
+  const padded = name.padEnd(width)
+  const prefix = useColor ? `\x1b[${color}m${padded}\x1b[0m | ` : `${padded} | `
+  let buffer = ''
+  return {
+    write(chunk: string): string {
+      buffer += chunk
+      const nl = buffer.lastIndexOf('\n')
+      if (nl < 0) return ''
+      const complete = buffer.slice(0, nl + 1)
+      buffer = buffer.slice(nl + 1)
+      return complete
+        .split('\n')
+        .slice(0, -1)
+        .map((l) => `${prefix}${l}\n`)
+        .join('')
+    },
+    flush(): string {
+      if (buffer.length === 0) return ''
+      const out = `${prefix}${buffer}\n`
+      buffer = ''
+      return out
+    },
+  }
+}
+
+export async function composeLogs({
+  rootCwd,
+  follow,
+  out = process.stdout,
+  err = process.stderr,
+  signal,
+}: ComposeLogsOptions): Promise<ComposeLogsResult> {
+  const agents = discoverAgents(rootCwd)
+
+  const liveness = await Promise.all(
+    agents.map(async (a) => ({ agent: a, exists: await containerExists(a.containerName) })),
+  )
+  const attached = liveness.filter((l) => l.exists).map((l) => l.agent)
+  const missing = liveness.filter((l) => !l.exists).map((l) => l.agent)
+
+  for (const a of missing) {
+    err.write(`compose: skipping ${a.name} (container not running)\n`)
+  }
+  if (attached.length === 0) return { agents, attached, missing, exitCode: 0 }
+
+  const bun = getBun()
+  if (!bun) {
+    err.write('compose: bun runtime not available\n')
+    return { agents, attached, missing, exitCode: 1 }
+  }
+
+  const width = attached.reduce((w, a) => Math.max(w, a.name.length), 0)
+  const useColor = supportsColor(out)
+
+  const procs = attached.map((agent) => {
+    const cmd = follow ? ['docker', 'logs', '-f', agent.containerName] : ['docker', 'logs', agent.containerName]
+    const proc = bun.spawn({ cmd, stdout: 'pipe', stderr: 'pipe' })
+    return { agent, proc }
+  })
+
+  const onAbort = (): void => {
+    for (const { proc } of procs) {
+      try {
+        proc.kill('SIGTERM')
+      } catch {
+        // already exited
+      }
+    }
+  }
+  signal?.addEventListener('abort', onAbort, { once: true })
+
+  const pumps = procs.flatMap(({ agent, proc }) => {
+    const color = colorFor(agent.name)
+    return [
+      pumpStream(proc.stdout, makeLinePrefixer(agent.name, width, color, useColor), out),
+      pumpStream(proc.stderr, makeLinePrefixer(agent.name, width, color, useColor), err),
+    ]
+  })
+
+  await Promise.all(pumps)
+  const exits = await Promise.all(procs.map((p) => p.proc.exited))
+  signal?.removeEventListener('abort', onAbort)
+
+  // 143 = 128 + SIGTERM(15). When we cancel via signal, every child exits 143;
+  // that's expected, not failure. Surface only the first non-OK, non-cancelled
+  // exit so a real `docker logs` failure (e.g. "no such container") still bubbles.
+  const exitCode = exits.find((c) => c !== 0 && c !== 143) ?? 0
+  return { agents, attached, missing, exitCode }
+}
+
+async function pumpStream(
+  stream: ReadableStream<Uint8Array>,
+  prefixer: { write: (s: string) => string; flush: () => string },
+  sink: NodeJS.WritableStream,
+): Promise<void> {
+  const decoder = new TextDecoder()
+  const reader = stream.getReader()
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      if (value && value.byteLength > 0) {
+        const out = prefixer.write(decoder.decode(value, { stream: true }))
+        if (out.length > 0) sink.write(out)
+      }
+    }
+    const tail = decoder.decode()
+    if (tail.length > 0) {
+      const out = prefixer.write(tail)
+      if (out.length > 0) sink.write(out)
+    }
+    const flushed = prefixer.flush()
+    if (flushed.length > 0) sink.write(flushed)
+  } finally {
+    reader.releaseLock()
+  }
+}
+
+function supportsColor(stream: NodeJS.WritableStream): boolean {
+  const tty = (stream as unknown as { isTTY?: boolean }).isTTY === true
+  if (!tty) return false
+  if (process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== '') return false
+  return true
+}

package/src/compose/restart.ts

@@ -0,0 +1,69 @@
+import { validateConfig } from '@/config'
+import { start, stop } from '@/container'
+
+import { discoverAgents, type AgentEntry } from './discover'
+import type { AgentResult, StartSuccess } from './start'
+import type { StopSuccess } from './stop'
+
+export type RestartData = { stop: StopSuccess; start: StartSuccess }
+
+export type ComposeRestartEvent =
+  | { kind: 'agent-start'; name: string }
+  | { kind: 'agent-stopped'; name: string }
+  | { kind: 'agent-done'; name: string; result: AgentResult<RestartData> }
+
+export type ComposeRestartOptions = {
+  rootCwd: string
+  preferredHostPort: number
+  forceBuild?: boolean
+  cliEntry?: string
+  onProgress?: (event: ComposeRestartEvent) => void
+}
+
+export type ComposeRestartResult = {
+  agents: AgentEntry[]
+  results: AgentResult<RestartData>[]
+}
+
+export async function composeRestart({
+  rootCwd,
+  preferredHostPort,
+  forceBuild = false,
+  cliEntry,
+  onProgress,
+}: ComposeRestartOptions): Promise<ComposeRestartResult> {
+  const agents = discoverAgents(rootCwd)
+  const results = await Promise.all(
+    agents.map(async (agent): Promise<AgentResult<RestartData>> => {
+      onProgress?.({ kind: 'agent-start', name: agent.name })
+      const result = await runOne(agent.name, agent.cwd, preferredHostPort, forceBuild, cliEntry, () => {
+        onProgress?.({ kind: 'agent-stopped', name: agent.name })
+      })
+      onProgress?.({ kind: 'agent-done', name: agent.name, result })
+      return result
+    }),
+  )
+  return { agents, results }
+}
+
+async function runOne(
+  name: string,
+  cwd: string,
+  preferredHostPort: number,
+  forceBuild: boolean,
+  cliEntry: string | undefined,
+  onStopped: () => void,
+): Promise<AgentResult<RestartData>> {
+  const validated = validateConfig(cwd)
+  if (!validated.ok) return { name, ok: false, reason: validated.reason }
+  try {
+    const stopped = await stop({ cwd })
+    if (!stopped.ok) return { name, ok: false, reason: stopped.reason }
+    onStopped()
+    const started = await start({ cwd, preferredHostPort, forceBuild, cliEntry })
+    if (!started.ok) return { name, ok: false, reason: started.reason }
+    return { name, ok: true, data: { stop: stopped, start: started } }
+  } catch (error) {
+    return { name, ok: false, reason: error instanceof Error ? error.message : String(error) }
+  }
+}

package/src/compose/start.ts

@@ -0,0 +1,62 @@
+import { validateConfig } from '@/config'
+import { start, type StartResult } from '@/container'
+
+import { discoverAgents, type AgentEntry } from './discover'
+
+export type AgentResult<T> = { name: string; ok: true; data: T } | { name: string; ok: false; reason: string }
+
+export type StartSuccess = Extract<StartResult, { ok: true }>
+
+export type ComposeStartEvent =
+  | { kind: 'agent-start'; name: string }
+  | { kind: 'agent-done'; name: string; result: AgentResult<StartSuccess> }
+
+export type ComposeStartOptions = {
+  rootCwd: string
+  preferredHostPort: number
+  forceBuild?: boolean
+  cliEntry?: string
+  onProgress?: (event: ComposeStartEvent) => void
+}
+
+export type ComposeStartResult = {
+  agents: AgentEntry[]
+  results: AgentResult<StartSuccess>[]
+}
+
+export async function composeStart({
+  rootCwd,
+  preferredHostPort,
+  forceBuild = false,
+  cliEntry,
+  onProgress,
+}: ComposeStartOptions): Promise<ComposeStartResult> {
+  const agents = discoverAgents(rootCwd)
+  const results = await Promise.all(
+    agents.map(async (agent): Promise<AgentResult<StartSuccess>> => {
+      onProgress?.({ kind: 'agent-start', name: agent.name })
+      const result = await runOne(agent.name, agent.cwd, preferredHostPort, forceBuild, cliEntry)
+      onProgress?.({ kind: 'agent-done', name: agent.name, result })
+      return result
+    }),
+  )
+  return { agents, results }
+}
+
+async function runOne(
+  name: string,
+  cwd: string,
+  preferredHostPort: number,
+  forceBuild: boolean,
+  cliEntry: string | undefined,
+): Promise<AgentResult<StartSuccess>> {
+  const validated = validateConfig(cwd)
+  if (!validated.ok) return { name, ok: false, reason: validated.reason }
+  try {
+    const data = await start({ cwd, preferredHostPort, forceBuild, cliEntry })
+    if (!data.ok) return { name, ok: false, reason: data.reason }
+    return { name, ok: true, data }
+  } catch (error) {
+    return { name, ok: false, reason: error instanceof Error ? error.message : String(error) }
+  }
+}

package/src/compose/status.ts

@@ -0,0 +1,28 @@
+import { inspectContainer, resolveHostPort } from '@/container'
+
+import { discoverAgents, type AgentEntry } from './discover'
+
+export type AgentRuntimeState = 'running' | 'stopped' | 'absent'
+
+export type AgentStatusEntry = AgentEntry & {
+  state: AgentRuntimeState
+  hostPort: number | null
+}
+
+export type ComposeStatusResult = {
+  rootCwd: string
+  entries: AgentStatusEntry[]
+}
+
+export async function composeStatus(rootCwd: string): Promise<ComposeStatusResult> {
+  const agents = discoverAgents(rootCwd)
+  const entries = await Promise.all(
+    agents.map(async (agent): Promise<AgentStatusEntry> => {
+      const container = await inspectContainer(agent.containerName)
+      const state: AgentRuntimeState = !container.exists ? 'absent' : container.running ? 'running' : 'stopped'
+      const hostPort = state === 'running' ? await resolveHostPort({ cwd: agent.cwd }).catch(() => null) : null
+      return { ...agent, state, hostPort }
+    }),
+  )
+  return { rootCwd, entries }
+}

package/src/compose/stop.ts

@@ -0,0 +1,43 @@
+import { stop, type StopResult } from '@/container'
+
+import { discoverAgents, type AgentEntry } from './discover'
+import type { AgentResult } from './start'
+
+export type StopSuccess = Extract<StopResult, { ok: true }>
+
+export type ComposeStopEvent =
+  | { kind: 'agent-start'; name: string }
+  | { kind: 'agent-done'; name: string; result: AgentResult<StopSuccess> }
+
+export type ComposeStopOptions = {
+  rootCwd: string
+  onProgress?: (event: ComposeStopEvent) => void
+}
+
+export type ComposeStopResult = {
+  agents: AgentEntry[]
+  results: AgentResult<StopSuccess>[]
+}
+
+export async function composeStop({ rootCwd, onProgress }: ComposeStopOptions): Promise<ComposeStopResult> {
+  const agents = discoverAgents(rootCwd)
+  const results = await Promise.all(
+    agents.map(async (agent): Promise<AgentResult<StopSuccess>> => {
+      onProgress?.({ kind: 'agent-start', name: agent.name })
+      const result = await runOne(agent.name, agent.cwd)
+      onProgress?.({ kind: 'agent-done', name: agent.name, result })
+      return result
+    }),
+  )
+  return { agents, results }
+}
+
+async function runOne(name: string, cwd: string): Promise<AgentResult<StopSuccess>> {
+  try {
+    const data = await stop({ cwd })
+    if (!data.ok) return { name, ok: false, reason: data.reason }
+    return { name, ok: true, data }
+  } catch (error) {
+    return { name, ok: false, reason: error instanceof Error ? error.message : String(error) }
+  }
+}