spexcode 0.6.2 → 0.6.6

package/spec-cli/src/attach.ts

@@ -1,43 +0,0 @@
-import { spawnSync } from 'node:child_process'
-import { networkInterfaces } from 'node:os'
-import { alive, apiBase, TMUX_SOCK } from './sessions.js'
-
-const AGENT_ALTERNATIVES = 'read the pane with `spex session show <SEL> --capture`, drive it with `session send` (plain text first; `--keys` only as a last resort)'
-
-// attach only makes sense on the machine that runs the tmux server — the backend's. The board the selector
-// resolved against IS that backend, so the test is: does the RESOLVED backend (see [[remote-client]]'s
-// ladder — flag / worker env / cwd record / fallback) point at this machine? Loopback and any address this
-// host owns count as local; anything else (a tailnet/LAN IP of another box, a hostname we can't claim)
-// fails loud with the reason and the remote-capable alternatives, never a silent local fallback onto a
-// tmux socket that holds no sessions.
-export async function assertLocalBackend(): Promise<void> {
-  const base = await apiBase()
-  let host: string
-  try { host = new URL(base).hostname } catch { host = '' }
-  const mine = new Set(['localhost', '127.0.0.1', '::1', '[::1]'])
-  for (const addrs of Object.values(networkInterfaces())) for (const a of addrs ?? []) mine.add(a.address)
-  if (mine.has(host)) return
-  console.error(`spex session attach: attach is LOCAL-only, and the resolved backend is another machine (${base}).
-The tmux session lives on THAT machine — a terminal can't be attached over HTTP. Either run attach there
-(e.g. over ssh), or ${AGENT_ALTERNATIVES} — those work remotely.`)
-  process.exit(2)
-}
-
-// foreground takeover of the session's real tmux window; returns only via detach (C-b d) or the session
-// ending. Interactive and blocking by design — a caller without a terminal (an agent inside its turn, a
-// pipe) is refused up front and pointed at the remote-capable verbs instead of tmux's bare "not a terminal".
-export async function attachSession(id: string): Promise<number> {
-  if (!process.stdin.isTTY || !process.stdout.isTTY) {
-    console.error(`spex session attach: attach is INTERACTIVE and needs a terminal — it blocks until you detach.
-An agent must not run it inside a turn (it freezes you); ${AGENT_ALTERNATIVES}.`)
-    process.exit(2)
-  }
-  if (!(await alive(id))) {
-    console.error(`spex session attach: ${id} is offline — no live tmux session to attach.
-Bring it back with \`spex session resume ${id}\`, or read its record with \`spex session show ${id}\`.`)
-    return 1
-  }
-  console.log(`attaching to ${id} — detach with C-b d (the session keeps running)`)
-  const r = spawnSync('tmux', ['-u', '-L', TMUX_SOCK, 'attach-session', '-t', id], { stdio: 'inherit' })
-  return r.status ?? 1
-}

package/spec-cli/src/claude-headless.ts

@@ -1,321 +0,0 @@
-import { rmSync } from 'node:fs'
-import { createServer, type Server, type Socket } from 'node:net'
-import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process'
-import { randomUUID } from 'node:crypto'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import type { DispatchResult, HarnessDeliveryRecord } from './harness.js'
-import { controlRequest, withTimeout } from './headless-controller.js'
-import { shQuote } from './sh.js'
-
-type ControlRequest = { type: 'deliver'; text: string; mode: 'steer' | 'wake' } | { type: 'interrupt' }
-type ClaudeHeadlessDeliveryRecord = HarnessDeliveryRecord & { status?: string }
-type ChildTurn = {
-  process: ChildProcessWithoutNullStreams
-  active: boolean
-  completed: boolean
-  exited: Promise<number | null>
-  teardown: Promise<void> | null
-  result: Promise<void>
-  sawResult: () => void
-  firstEvent: Promise<void>
-  sawFirstEvent: () => void
-  interruptAcks: Map<string, () => void>
-}
-
-const PKG = fileURLToPath(new URL('..', import.meta.url))
-const SPEX = join(PKG, 'bin', 'spex.mjs')
-const CONTROL_TIMEOUT_MS = 60_000
-const START_TIMEOUT_MS = 30_000
-const INTERRUPT_TIMEOUT_MS = 10_000
-const RESULT_WAIT_MS = 20_000
-const RESULT_EXIT_GRACE_MS = 500
-const TERM_EXIT_GRACE_MS = 500
-const KILL_EXIT_GRACE_MS = 2_000
-
-const userEvent = (text: string) => JSON.stringify({
-  type: 'user',
-  message: { role: 'user', content: [{ type: 'text', text }] },
-})
-
-export const claudeHeadlessSock = (id: string) => join(tmpdir(), `spexcode-ch-${id}.sock`)
-
-export function claudeHeadlessLaunchCommand(id: string, runtimeDir: string, claudeCmd: string): string {
-  return [shQuote(SPEX), 'internal', 'claude-headless-run', shQuote(id), shQuote(runtimeDir), shQuote(claudeCmd), '--'].join(' ')
-}
-
-export const deliverViaClaudeHeadless = (rec: ClaudeHeadlessDeliveryRecord, text: string) =>
-  controlRequest(claudeHeadlessSock(rec.session), { type: 'deliver', text, mode: rec.status === 'active' ? 'steer' : 'wake' }, {
-    name: 'claude-headless', session: rec.session, timeoutMs: CONTROL_TIMEOUT_MS,
-    rejected: 'claude-headless control rejected the request',
-  })
-
-export const interruptClaudeHeadless = (rec: HarnessDeliveryRecord) =>
-  controlRequest(claudeHeadlessSock(rec.session), { type: 'interrupt' }, {
-    name: 'claude-headless', session: rec.session, timeoutMs: CONTROL_TIMEOUT_MS,
-    rejected: 'claude-headless control rejected the request',
-  })
-
-export class ClaudeHeadlessController {
-  private server: Server | null = null
-  private child: ChildTurn | null = null
-  private controlQueue: Promise<void> = Promise.resolve()
-  private closing = false
-  private readonly socketPath: string
-
-  constructor(
-    private readonly id: string,
-    _runtimeDir: string,
-    private readonly claudeCmd: string,
-    private readonly cwd = process.cwd(),
-  ) {
-    this.socketPath = claudeHeadlessSock(id)
-  }
-
-  async start(initialPrompt?: string): Promise<void> {
-    try { rmSync(this.socketPath, { force: true }) } catch { /* stale control socket is replaced at startup */ }
-    this.server = createServer((socket) => this.accept(socket))
-    await new Promise<void>((resolve, reject) => {
-      const onError = (error: Error) => { this.server?.off('listening', onListening); reject(error) }
-      const onListening = () => { this.server?.off('error', onError); resolve() }
-      this.server!.once('error', onError)
-      this.server!.once('listening', onListening)
-      this.server!.listen(this.socketPath)
-    })
-    if (initialPrompt) void this.spawnTurn(initialPrompt, false).catch((error) => {
-      console.error(`[spex claude-headless] initial turn failed: ${(error as Error).message}`)
-    })
-  }
-
-  async close(): Promise<void> {
-    if (this.closing) return
-    this.closing = true
-    const child = this.child
-    try {
-      if (child) await this.ensureTurnExit(child)
-    } finally {
-      await new Promise<void>((resolve) => {
-        if (!this.server) return resolve()
-        this.server.close(() => resolve())
-      })
-      try { rmSync(this.socketPath, { force: true }) } catch { /* best-effort cleanup after close */ }
-    }
-  }
-
-  private accept(socket: Socket): void {
-    socket.setEncoding('utf8')
-    let buffer = ''
-    let handled = false
-    socket.on('data', (chunk) => {
-      if (handled) return
-      buffer += chunk
-      const nl = buffer.indexOf('\n')
-      if (nl < 0) return
-      handled = true
-      let request: ControlRequest
-      try {
-        request = JSON.parse(buffer.slice(0, nl)) as ControlRequest
-      } catch (error) {
-        socket.end(`${JSON.stringify({ ok: false, error: `invalid control request: ${(error as Error).message}` })}\n`)
-        return
-      }
-      this.controlQueue = this.controlQueue.then(async () => {
-        const result = await this.handle(request).catch((error) => ({ ok: false, error: (error as Error).message }))
-        socket.end(`${JSON.stringify(result)}\n`)
-      })
-    })
-  }
-
-  private async handle(request: ControlRequest): Promise<DispatchResult> {
-    if (request.type === 'deliver') {
-      if (!request.text) return { ok: false, error: 'empty prompt - nothing to deliver' }
-      const current = this.child
-      if (request.mode === 'steer' && current?.active && current.process.stdin.writable) {
-        await this.writeLine(current, userEvent(request.text))
-        return { ok: true }
-      }
-      if (current?.active) {
-        await Promise.race([
-          withTimeout(current.result, RESULT_WAIT_MS, 'previous claude-headless turn did not reach its result before idle wake'),
-          current.exited.then((code) => { throw new Error(`previous claude-headless turn exited before its result (code ${code ?? 'signal'})`) }),
-        ])
-      }
-      if (current) await this.ensureTurnExit(current)
-      await this.spawnTurn(request.text, true)
-      return { ok: true }
-    }
-    if (request.type === 'interrupt') return this.interrupt()
-    return { ok: false, error: 'unknown claude-headless control request' }
-  }
-
-  private async interrupt(): Promise<DispatchResult> {
-    const child = this.child
-    if (!child?.active || !child.process.stdin.writable) return { ok: true }
-    const requestId = randomUUID()
-    const ack = new Promise<void>((resolve) => child.interruptAcks.set(requestId, resolve))
-    await this.writeLine(child, JSON.stringify({
-      type: 'control_request',
-      request_id: requestId,
-      request: { subtype: 'interrupt' },
-    }))
-    try {
-      await withTimeout(ack, INTERRUPT_TIMEOUT_MS, `claude-headless interrupt was not confirmed for session ${this.id}`)
-      return { ok: true }
-    } finally {
-      child.interruptAcks.delete(requestId)
-    }
-  }
-
-  private async spawnTurn(text: string, resume: boolean): Promise<void> {
-    if (this.closing) throw new Error('claude-headless controller is closing')
-    const mode = resume ? ['--resume', this.id] : ['--session-id', this.id]
-    const args = ['-p', ...mode, '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose']
-    const command = `exec ${this.claudeCmd} ${args.map(shQuote).join(' ')}`
-    const childProcess = spawn('/bin/sh', ['-lc', command], {
-      cwd: this.cwd,
-      env: process.env,
-      detached: true,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    })
-    let sawFirstEvent!: () => void
-    const firstEvent = new Promise<void>((resolve) => { sawFirstEvent = resolve })
-    let resolveExit!: (code: number | null) => void
-    const exited = new Promise<number | null>((resolve) => { resolveExit = resolve })
-    let sawResult!: () => void
-    const result = new Promise<void>((resolve) => { sawResult = resolve })
-    const turn: ChildTurn = {
-      process: childProcess,
-      active: true,
-      completed: false,
-      exited,
-      teardown: null,
-      result,
-      sawResult,
-      firstEvent,
-      sawFirstEvent,
-      interruptAcks: new Map(),
-    }
-    this.child = turn
-    let stdoutBuffer = ''
-    childProcess.stdout.setEncoding('utf8')
-    childProcess.stderr.pipe(process.stderr)
-    childProcess.stdout.on('data', (chunk) => {
-      stdoutBuffer += chunk
-      for (;;) {
-        const nl = stdoutBuffer.indexOf('\n')
-        if (nl < 0) break
-        const line = stdoutBuffer.slice(0, nl)
-        stdoutBuffer = stdoutBuffer.slice(nl + 1)
-        const nativeLine = `${line}\n`
-        globalThis.process.stdout.write(nativeLine)
-        turn.sawFirstEvent()
-        this.observeEvent(turn, line)
-      }
-    })
-    childProcess.once('error', (error) => {
-      console.error(`[spex claude-headless] child spawn failed: ${error.message}`)
-    })
-    childProcess.once('close', (code) => {
-      turn.active = false
-      if (stdoutBuffer) console.error('[spex claude-headless] dropped a partial non-line stdout event')
-      if (this.child === turn) this.child = null
-      resolveExit(code)
-      if (!turn.completed && code !== 0 && !this.closing) {
-        void import('./harness.js').then(({ reportHeadlessTurnExit }) => reportHeadlessTurnExit(this.id, 'claude-headless', code, this.cwd))
-      }
-    })
-    await this.writeLine(turn, userEvent(text))
-    await Promise.race([
-      withTimeout(turn.firstEvent, START_TIMEOUT_MS, `claude-headless child produced no stream event for session ${this.id}`),
-      turn.exited.then((code) => { throw new Error(`claude-headless child exited before accepting the turn (code ${code ?? 'signal'})`) }),
-    ])
-  }
-
-  private observeEvent(turn: ChildTurn, line: string): void {
-    let event: any
-    try { event = JSON.parse(line) } catch { return }
-    if (event?.type === 'control_response' && typeof event?.response?.request_id === 'string') {
-      turn.interruptAcks.get(event.response.request_id)?.()
-    }
-    if (event?.type === 'result' && !turn.completed) {
-      turn.completed = true
-      turn.active = false
-      turn.sawResult()
-      void this.ensureTurnExit(turn).catch((error) => {
-        console.error(`[spex claude-headless] completed turn teardown failed: ${(error as Error).message}`)
-      })
-    }
-  }
-
-  private ensureTurnExit(turn: ChildTurn): Promise<void> {
-    turn.teardown ??= this.terminateTurn(turn)
-    return turn.teardown
-  }
-
-  private async terminateTurn(turn: ChildTurn): Promise<void> {
-    if (turn.completed) {
-      if (turn.process.stdin.writable) turn.process.stdin.end()
-      if (await this.waitForTurnExit(turn, RESULT_EXIT_GRACE_MS)) return
-      this.signalTurn(turn, 'SIGKILL')
-      await withTimeout(
-        turn.exited,
-        KILL_EXIT_GRACE_MS,
-        `claude-headless completed turn process group ${turn.process.pid ?? 'unknown'} did not exit after SIGKILL`,
-      )
-      return
-    }
-    this.signalTurn(turn, 'SIGTERM')
-    if (await this.waitForTurnExit(turn, TERM_EXIT_GRACE_MS)) return
-    this.signalTurn(turn, 'SIGKILL')
-    await withTimeout(
-      turn.exited,
-      KILL_EXIT_GRACE_MS,
-      `claude-headless turn process group ${turn.process.pid ?? 'unknown'} did not exit after SIGKILL`,
-    )
-  }
-
-  private async waitForTurnExit(turn: ChildTurn, timeoutMs: number): Promise<boolean> {
-    try {
-      await withTimeout(turn.exited, timeoutMs, 'turn exit grace elapsed')
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  private signalTurn(turn: ChildTurn, signal: NodeJS.Signals): void {
-    const pid = turn.process.pid
-    try {
-      if (pid) process.kill(-pid, signal)
-      else turn.process.kill(signal)
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'ESRCH') throw error
-    }
-  }
-
-  private writeLine(turn: ChildTurn, line: string): Promise<void> {
-    return new Promise((resolve, reject) => {
-      if (!turn.process.stdin.writable) return reject(new Error('claude-headless child stdin is not writable'))
-      turn.process.stdin.write(`${line}\n`, (error) => error ? reject(error) : resolve())
-    })
-  }
-}
-
-export async function runClaudeHeadlessController(
-  id: string,
-  runtimeDir: string,
-  claudeCmd: string,
-  tail: string[],
-): Promise<void> {
-  const controller = new ClaudeHeadlessController(id, runtimeDir, claudeCmd)
-  const resume = tail[0] === '--resume'
-  const prompt = resume ? undefined : tail[0] === '--session-id' ? tail.slice(2).join(' ') : tail.join(' ')
-  await controller.start(prompt)
-  await new Promise<void>((resolve) => {
-    const stop = () => void controller.close().finally(resolve)
-    process.once('SIGINT', stop)
-    process.once('SIGTERM', stop)
-    process.once('SIGHUP', stop)
-  })
-}