theslopmachine 0.6.2 → 0.7.0

package/assets/slopmachine/utils/claude_live_common.mjs

@@ -0,0 +1,406 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises'
+import http from 'node:http'
+import net from 'node:net'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { fileURLToPath } from 'node:url'
+import { spawn } from 'node:child_process'
+
+import { emitFailure, emitSuccess, parseArgs, readJsonFile, readPrompt, sleep, waitForRateLimitReset, writeFileIfNeeded, writeJsonIfNeeded } from './claude_worker_common.mjs'
+
+export { emitFailure, emitSuccess, parseArgs, readPrompt, sleep, waitForRateLimitReset, writeJsonIfNeeded }
+
+export const DEFAULT_LAUNCH_TIMEOUT_MS = 3600000
+export const DEFAULT_TURN_TIMEOUT_MS = 3600000
+export const DEFAULT_CHANNEL_POST_TIMEOUT_MS = 10000
+export const DEFAULT_POLL_INTERVAL_MS = 500
+
+export function buildRuntimePaths(runtimeDir) {
+  const absoluteRuntimeDir = path.resolve(runtimeDir)
+  return {
+    runtimeDir: absoluteRuntimeDir,
+    stateFile: path.join(absoluteRuntimeDir, 'state.json'),
+    resultFile: path.join(absoluteRuntimeDir, 'result.json'),
+    settingsFile: path.join(absoluteRuntimeDir, 'settings.json'),
+    mcpConfigFile: path.join(absoluteRuntimeDir, 'mcp.json'),
+    channelStateFile: path.join(absoluteRuntimeDir, 'channel-state.json'),
+    channelLogFile: path.join(absoluteRuntimeDir, 'channel.log'),
+    hookEventsFile: path.join(absoluteRuntimeDir, 'hook-events.jsonl'),
+    turnsDir: path.join(absoluteRuntimeDir, 'turns'),
+  }
+}
+
+export function resolveUtilsDir() {
+  return path.dirname(fileURLToPath(import.meta.url))
+}
+
+export async function ensureRuntimeDirs(paths) {
+  await fs.mkdir(paths.runtimeDir, { recursive: true })
+  await fs.mkdir(paths.turnsDir, { recursive: true })
+}
+
+export async function readJsonIfExists(filePath) {
+  try {
+    return await readJsonFile(filePath)
+  } catch (error) {
+    if (error && typeof error === 'object' && error.code === 'ENOENT') {
+      return null
+    }
+    throw error
+  }
+}
+
+export async function readState(runtimeDir) {
+  return readJsonIfExists(buildRuntimePaths(runtimeDir).stateFile)
+}
+
+export async function writeState(runtimeDir, patch) {
+  const paths = buildRuntimePaths(runtimeDir)
+  const existing = (await readJsonIfExists(paths.stateFile)) || {}
+  const next = {
+    ...existing,
+    ...patch,
+    updated_at: new Date().toISOString(),
+  }
+  await writeJsonIfNeeded(paths.stateFile, next)
+  return next
+}
+
+export async function clearRuntimeArtifacts(paths) {
+  await writeFileIfNeeded(paths.hookEventsFile, '')
+  await writeFileIfNeeded(paths.channelLogFile, '')
+  await fs.rm(paths.channelStateFile, { force: true })
+  await fs.rm(paths.resultFile, { force: true })
+}
+
+export function sanitizeName(value) {
+  return String(value || 'lane')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 40) || 'lane'
+}
+
+export function makeSuffix(size = 4) {
+  return crypto.randomBytes(size).toString('hex')
+}
+
+export function makeToken(size = 24) {
+  return crypto.randomBytes(size).toString('hex')
+}
+
+export function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`
+}
+
+export async function allocatePort(host = '127.0.0.1') {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer()
+    server.once('error', reject)
+    server.listen(0, host, () => {
+      const address = server.address()
+      const port = address && typeof address === 'object' ? address.port : null
+      server.close((error) => {
+        if (error) {
+          reject(error)
+          return
+        }
+        resolve(port)
+      })
+    })
+  })
+}
+
+export async function runCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString()
+    })
+
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString()
+    })
+
+    child.on('error', reject)
+    child.on('close', (code) => {
+      resolve({ code: code ?? 1, stdout, stderr })
+    })
+  })
+}
+
+export async function tmuxHasSession(sessionName) {
+  if (!sessionName) return false
+  const result = await runCommand('tmux', ['has-session', '-t', sessionName])
+  return result.code === 0
+}
+
+export async function tmuxCapturePane(sessionName) {
+  const result = await runCommand('tmux', ['capture-pane', '-p', '-t', sessionName])
+  return result.code === 0 ? result.stdout : ''
+}
+
+export async function tmuxSendEnter(sessionName) {
+  return runCommand('tmux', ['send-keys', '-t', sessionName, 'Enter'])
+}
+
+export async function tmuxKillSession(sessionName) {
+  return runCommand('tmux', ['kill-session', '-t', sessionName])
+}
+
+export async function waitFor(predicate, { timeoutMs, intervalMs = DEFAULT_POLL_INTERVAL_MS, errorMessage }) {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    const value = await predicate()
+    if (value) {
+      return value
+    }
+    await sleep(intervalMs)
+  }
+  throw new Error(errorMessage)
+}
+
+export async function maybeAcceptDevelopmentChannelsPrompt(sessionName, timeoutMs = 30000) {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    const pane = await tmuxCapturePane(sessionName)
+    if (pane.includes('Listening for channel messages from:')) {
+      return false
+    }
+    if (pane.includes('I am using this for local development')) {
+      await tmuxSendEnter(sessionName)
+      return true
+    }
+    await sleep(DEFAULT_POLL_INTERVAL_MS)
+  }
+  return false
+}
+
+export async function waitForChannelReady(paths, timeoutMs) {
+  return waitFor(async () => {
+    const channelState = await readJsonIfExists(paths.channelStateFile)
+    if (channelState?.ready_for_notifications) {
+      return channelState
+    }
+    return null
+  }, {
+    timeoutMs,
+    errorMessage: 'Timed out waiting for Claude channel readiness',
+  })
+}
+
+export async function readJsonl(filePath) {
+  try {
+    const content = await fs.readFile(filePath, 'utf8')
+    return content
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => JSON.parse(line))
+  } catch (error) {
+    if (error && typeof error === 'object' && error.code === 'ENOENT') {
+      return []
+    }
+    throw error
+  }
+}
+
+export async function waitForHookEvent(paths, startIndex, labels, timeoutMs) {
+  return waitFor(async () => {
+    const events = await readJsonl(paths.hookEventsFile)
+    const pending = events.slice(startIndex)
+    const match = pending.find((event) => labels.has(event.label))
+    if (!match) {
+      return null
+    }
+    return {
+      event: match,
+      eventsLength: events.length,
+    }
+  }, {
+    timeoutMs,
+    errorMessage: `Timed out waiting for hook event: ${Array.from(labels).join(', ')}`,
+  })
+}
+
+export function buildHookSettings({ runtimeDir, utilsDir, agentName = 'developer', subagentModel = null }) {
+  const buildCommand = (label) => `python3 ${shellQuote(path.join(utilsDir, 'claude_live_hook.py'))} --runtime-dir ${shellQuote(runtimeDir)} ${label}`
+  const settings = {
+    agent: agentName,
+    hooks: {
+      SessionStart: [{ hooks: [{ type: 'command', command: buildCommand('SessionStart') }] }],
+      UserPromptSubmit: [{ hooks: [{ type: 'command', command: buildCommand('UserPromptSubmit') }] }],
+      Stop: [{ hooks: [{ type: 'command', command: buildCommand('Stop') }] }],
+      StopFailure: [{ hooks: [{ type: 'command', command: buildCommand('StopFailure') }] }],
+    },
+  }
+
+  if (subagentModel) {
+    settings.env = {
+      CLAUDE_CODE_SUBAGENT_MODEL: subagentModel,
+    }
+  }
+
+  return settings
+}
+
+export function buildMcpConfig({ paths, utilsDir, channelName, lane, port, token }) {
+  return {
+    mcpServers: {
+      [channelName]: {
+        command: 'node',
+        args: [
+          path.join(utilsDir, 'claude_live_channel.mjs'),
+          '--port',
+          String(port),
+          '--token',
+          token,
+          '--state-file',
+          paths.channelStateFile,
+          '--log-file',
+          paths.channelLogFile,
+          '--channel-name',
+          channelName,
+          '--lane',
+          lane,
+        ],
+      },
+    },
+  }
+}
+
+export function buildClaudeLaunchCommand({ claudeCommand, agentName, displayName, settingsFile, mcpConfigFile, channelName, model }) {
+  const parts = [
+    shellQuote(claudeCommand),
+    '--agent',
+    shellQuote(agentName),
+    '-n',
+    shellQuote(displayName),
+    '--settings',
+    shellQuote(settingsFile),
+    '--mcp-config',
+    shellQuote(mcpConfigFile),
+    '--dangerously-skip-permissions',
+    '--dangerously-load-development-channels',
+    shellQuote(`server:${channelName}`),
+  ]
+
+  if (model) {
+    parts.push('--model', shellQuote(model))
+  }
+
+  return parts.join(' ')
+}
+
+export async function postPromptToChannel({ state, prompt, turnId, timeoutMs = DEFAULT_CHANNEL_POST_TIMEOUT_MS }) {
+  return new Promise((resolve, reject) => {
+    const request = http.request({
+      hostname: '127.0.0.1',
+      port: state.channel_port,
+      path: '/',
+      method: 'POST',
+      headers: {
+        'content-type': 'text/plain; charset=utf-8',
+        'content-length': Buffer.byteLength(prompt, 'utf8'),
+        'x-bridge-token': state.channel_token,
+        'x-lane': state.lane,
+        'x-turn-id': turnId,
+      },
+      timeout: timeoutMs,
+    }, (response) => {
+      let body = ''
+      response.on('data', (chunk) => {
+        body += chunk.toString()
+      })
+      response.on('end', () => {
+        resolve({
+          statusCode: response.statusCode || 0,
+          body,
+        })
+      })
+    })
+
+    request.on('error', reject)
+    request.on('timeout', () => {
+      request.destroy(new Error('channel_post_timeout'))
+    })
+    request.write(prompt)
+    request.end()
+  })
+}
+
+export function buildTurnId(lastTurnNumber) {
+  return String(lastTurnNumber + 1).padStart(4, '0')
+}
+
+export async function writeTurnArtifacts(paths, turnId, prompt, resultPayload, extraResultFile = null) {
+  const turnDir = path.join(paths.turnsDir, turnId)
+  await fs.mkdir(turnDir, { recursive: true })
+  await writeFileIfNeeded(path.join(turnDir, 'prompt.txt'), `${prompt}\n`)
+  await writeJsonIfNeeded(path.join(turnDir, 'result.json'), resultPayload)
+  await writeJsonIfNeeded(paths.resultFile, resultPayload)
+  if (extraResultFile) {
+    await writeJsonIfNeeded(extraResultFile, resultPayload)
+  }
+  return turnDir
+}
+
+export function extractFailureMessage(payload) {
+  if (!payload) return ''
+
+  const candidates = [
+    payload.message,
+    payload.error,
+    payload.failure_reason,
+    payload.reason,
+    payload.details,
+  ]
+
+  for (const candidate of candidates) {
+    if (typeof candidate === 'string' && candidate.trim()) {
+      return candidate.trim()
+    }
+    if (candidate && typeof candidate === 'object') {
+      return JSON.stringify(candidate)
+    }
+  }
+
+  return JSON.stringify(payload)
+}
+
+export function classifyStopFailure(event, fallbackSid = null) {
+  const payload = event?.payload || null
+  const sid = payload?.session_id || fallbackSid || null
+  const message = extractFailureMessage(payload) || 'claude_stop_failure'
+
+  if (/hit your limit|usage limit|capacity|overloaded/i.test(message)) {
+    return {
+      result: { ok: false, code: 'claude_usage_limit', msg: 'usage_limit', detail: message, sid },
+      nextStatus: 'blocked',
+    }
+  }
+
+  return {
+    result: { ok: false, code: 'claude_stop_failure', msg: message, sid },
+    nextStatus: 'failed',
+  }
+}
+
+export function buildFailureResult(code, message, sid = null) {
+  return {
+    ok: false,
+    code,
+    msg: message,
+    sid,
+  }
+}

package/assets/slopmachine/utils/claude_live_hook.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+import sys
+
+
+def parse_args(argv: list[str]) -> tuple[Path, str]:
+    runtime_dir = None
+    label = 'unknown'
+    index = 0
+    while index < len(argv):
+        value = argv[index]
+        if value == '--runtime-dir':
+            index += 1
+            runtime_dir = Path(argv[index])
+        else:
+            label = value
+        index += 1
+    if runtime_dir is None:
+        raise SystemExit('Missing --runtime-dir')
+    return runtime_dir, label
+
+
+def main() -> None:
+    runtime_dir, label = parse_args(sys.argv[1:])
+    payload_raw = sys.stdin.read().strip()
+    try:
+        payload = json.loads(payload_raw) if payload_raw else None
+    except Exception:
+        payload = {'raw': payload_raw}
+
+    record = {
+        'ts': datetime.now(timezone.utc).isoformat(),
+        'label': label,
+        'payload': payload,
+    }
+
+    runtime_dir.mkdir(parents=True, exist_ok=True)
+    hook_log = runtime_dir / 'hook-events.jsonl'
+    with hook_log.open('a', encoding='utf-8') as handle:
+        handle.write(json.dumps(record) + '\n')
+
+
+if __name__ == '__main__':
+    main()

package/assets/slopmachine/utils/claude_live_launch.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+
+import path from 'node:path'
+
+import {
+  DEFAULT_LAUNCH_TIMEOUT_MS,
+  allocatePort,
+  buildClaudeLaunchCommand,
+  buildHookSettings,
+  buildMcpConfig,
+  buildRuntimePaths,
+  clearRuntimeArtifacts,
+  emitFailure,
+  emitSuccess,
+  ensureRuntimeDirs,
+  makeSuffix,
+  makeToken,
+  maybeAcceptDevelopmentChannelsPrompt,
+  parseArgs,
+  readJsonIfExists,
+  resolveUtilsDir,
+  runCommand,
+  sanitizeName,
+  tmuxHasSession,
+  tmuxKillSession,
+  waitForChannelReady,
+  waitForHookEvent,
+  writeJsonIfNeeded,
+  writeState,
+} from './claude_live_common.mjs'
+
+const argv = parseArgs(process.argv.slice(2))
+
+const runtimeDir = argv['runtime-dir']
+const cwd = argv.cwd ? path.resolve(argv.cwd) : null
+const lane = argv.lane
+const agentName = argv.agent || 'developer'
+const claudeCommand = argv['claude-command'] || 'claude'
+const launchTimeoutMs = Number.parseInt(argv['timeout-ms'] || String(DEFAULT_LAUNCH_TIMEOUT_MS), 10)
+const replace = argv.replace === '1'
+
+if (!runtimeDir || !lane || !cwd) {
+  emitFailure('claude_live_launch_invalid_args', 'Missing required launch arguments', {
+    state_file: runtimeDir ? buildRuntimePaths(runtimeDir).stateFile : null,
+  })
+  process.exit(1)
+}
+
+const paths = buildRuntimePaths(runtimeDir)
+
+try {
+  await ensureRuntimeDirs(paths)
+
+  const existingState = await readJsonIfExists(paths.stateFile)
+  if (existingState?.tmux_session && await tmuxHasSession(existingState.tmux_session)) {
+    if (!replace) {
+      emitSuccess(existingState.sid || null, {
+        state_file: paths.stateFile,
+        result_file: paths.resultFile,
+      })
+      process.exit(0)
+    }
+    await tmuxKillSession(existingState.tmux_session)
+  } else if (existingState && !replace && existingState.status && existingState.status !== 'stopped') {
+    emitFailure('claude_live_state_stale', 'Existing runtime state is stale. Re-run with --replace 1 to recover it.', {
+      sid: existingState.sid || null,
+      state_file: paths.stateFile,
+      result_file: paths.resultFile,
+    })
+    process.exit(1)
+  }
+
+  const suffix = makeSuffix()
+  const tmuxSession = argv['tmux-session'] || `sm-${sanitizeName(lane)}-${suffix}`
+  const channelName = argv['channel-name'] || `slopmachine-${sanitizeName(lane)}-${suffix}`
+  const channelPort = await allocatePort()
+  const channelToken = makeToken()
+  const utilsDir = resolveUtilsDir()
+
+  await clearRuntimeArtifacts(paths)
+  await writeState(runtimeDir, {
+    lane,
+    backend: 'claude-live',
+    status: 'starting',
+    cwd,
+    sid: null,
+    agent_name: agentName,
+    model: argv.model || null,
+    tmux_session: tmuxSession,
+    channel_name: channelName,
+    channel_port: channelPort,
+    channel_token: channelToken,
+    runtime_dir: paths.runtimeDir,
+    settings_file: paths.settingsFile,
+    mcp_config_file: paths.mcpConfigFile,
+    hook_events_file: paths.hookEventsFile,
+    channel_state_file: paths.channelStateFile,
+    result_file: paths.resultFile,
+    transcript_path: null,
+    current_turn_id: null,
+    last_completed_turn_id: null,
+    last_hook_event: null,
+    last_error: null,
+    last_turn_number: 0,
+    started_at: new Date().toISOString(),
+  })
+
+  await Promise.all([
+    writeJsonIfNeeded(paths.settingsFile, buildHookSettings({
+      runtimeDir: paths.runtimeDir,
+      utilsDir,
+      agentName,
+      subagentModel: argv.model || 'sonnet',
+    })),
+    writeJsonIfNeeded(paths.mcpConfigFile, buildMcpConfig({
+      paths,
+      utilsDir,
+      channelName,
+      lane,
+      port: channelPort,
+      token: channelToken,
+    })),
+  ])
+
+  const launchCommand = buildClaudeLaunchCommand({
+    claudeCommand,
+    agentName,
+    displayName: lane,
+    settingsFile: paths.settingsFile,
+    mcpConfigFile: paths.mcpConfigFile,
+    channelName,
+    model: argv.model || null,
+  })
+
+  const launchResult = await runCommand('tmux', ['new-session', '-d', '-s', tmuxSession, '-c', cwd, launchCommand])
+  if (launchResult.code !== 0) {
+    emitFailure('claude_live_launch_failed', launchResult.stderr.trim() || 'Failed to start tmux Claude session', {
+      state_file: paths.stateFile,
+      result_file: paths.resultFile,
+    })
+    process.exit(1)
+  }
+
+  await maybeAcceptDevelopmentChannelsPrompt(tmuxSession, Math.min(launchTimeoutMs, 30000))
+
+  const [{ event }, channelState] = await Promise.all([
+    waitForHookEvent(paths, 0, new Set(['SessionStart']), launchTimeoutMs),
+    waitForChannelReady(paths, launchTimeoutMs),
+  ])
+
+  const sessionId = event.payload?.session_id || null
+  const transcriptPath = event.payload?.transcript_path || null
+  await writeState(runtimeDir, {
+    status: 'idle',
+    sid: sessionId,
+    transcript_path: transcriptPath,
+    last_hook_event: 'SessionStart',
+    last_error: null,
+    channel_status: channelState.status || 'ready',
+  })
+
+  emitSuccess(sessionId, {
+    state_file: paths.stateFile,
+    result_file: paths.resultFile,
+  })
+} catch (error) {
+  const state = await readJsonIfExists(paths.stateFile)
+  if (state?.tmux_session && await tmuxHasSession(state.tmux_session)) {
+    await tmuxKillSession(state.tmux_session)
+  }
+  await writeState(runtimeDir, {
+    status: 'failed',
+    last_error: error instanceof Error ? error.message : String(error),
+  })
+  emitFailure('claude_live_launch_failed', error instanceof Error ? error.message : String(error), {
+    sid: state?.sid || null,
+    state_file: paths.stateFile,
+    result_file: paths.resultFile,
+  })
+  process.exit(1)
+}

package/assets/slopmachine/utils/claude_live_status.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+import { buildRuntimePaths, parseArgs, readState, tmuxHasSession } from './claude_live_common.mjs'
+
+const argv = parseArgs(process.argv.slice(2))
+const runtimeDir = argv['runtime-dir']
+
+if (!runtimeDir) {
+  process.stdout.write(JSON.stringify({ ok: false, code: 'claude_live_status_invalid_args', msg: 'Missing --runtime-dir' }))
+  process.exit(1)
+}
+
+const state = await readState(runtimeDir)
+if (!state) {
+  process.stdout.write(JSON.stringify({ ok: false, code: 'claude_live_status_missing', msg: 'Missing bridge state', state_file: buildRuntimePaths(runtimeDir).stateFile }))
+  process.exit(1)
+}
+
+const tmuxAlive = await tmuxHasSession(state.tmux_session)
+const { channel_token: _channelToken, ...safeState } = state
+process.stdout.write(JSON.stringify({
+  ok: true,
+  ...safeState,
+  tmux_alive: tmuxAlive,
+}))

package/assets/slopmachine/utils/claude_live_stop.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import { buildRuntimePaths, emitFailure, emitSuccess, parseArgs, readState, tmuxHasSession, tmuxKillSession, writeState } from './claude_live_common.mjs'
+
+const argv = parseArgs(process.argv.slice(2))
+const runtimeDir = argv['runtime-dir']
+
+if (!runtimeDir) {
+  emitFailure('claude_live_stop_invalid_args', 'Missing --runtime-dir')
+  process.exit(1)
+}
+
+const paths = buildRuntimePaths(runtimeDir)
+const state = await readState(runtimeDir)
+
+if (!state) {
+  emitFailure('claude_live_stop_missing', 'Missing bridge state', { state_file: paths.stateFile })
+  process.exit(1)
+}
+
+if (state.tmux_session && await tmuxHasSession(state.tmux_session)) {
+  const stopResult = await tmuxKillSession(state.tmux_session)
+  if (stopResult.code !== 0) {
+    emitFailure('claude_live_stop_failed', stopResult.stderr.trim() || 'Failed to stop tmux session', {
+      sid: state.sid || null,
+      state_file: paths.stateFile,
+      result_file: paths.resultFile,
+    })
+    process.exit(1)
+  }
+}
+
+await writeState(runtimeDir, {
+  status: 'stopped',
+  current_turn_id: null,
+  current_turn_prompt_file: null,
+  current_turn_started_at: null,
+  last_error: null,
+  stopped_at: new Date().toISOString(),
+})
+
+emitSuccess(state.sid || null, {
+  state_file: paths.stateFile,
+  result_file: paths.resultFile,
+})