theslopmachine 0.6.2 → 0.7.1

package/assets/slopmachine/utils/claude_live_launch.mjs

@@ -0,0 +1,187 @@
+#!/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 laneModel = argv.model || 'sonnet'
+const laneEffort = argv.effort || null
+const subagentModel = argv['subagent-model'] || 'sonnet'
+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: laneModel,
+    effort: laneEffort,
+    subagent_model: subagentModel,
+    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,
+    })),
+    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: laneModel,
+    effort: laneEffort,
+  })
+
+  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,46 @@
+#!/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_prompt_source: 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,
+})

package/assets/slopmachine/utils/claude_live_turn.mjs

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+
+import {
+  DEFAULT_TURN_TIMEOUT_MS,
+  buildFailureResult,
+  buildRuntimePaths,
+  buildTurnId,
+  classifyStopFailure,
+  emitFailure,
+  emitSuccess,
+  postPromptToChannel,
+  parseArgs,
+  readJsonl,
+  readPromptInput,
+  readState,
+  tmuxHasSession,
+  waitForRateLimitReset,
+  waitForChannelReady,
+  waitForHookEvent,
+  writeState,
+  writeTurnArtifacts,
+} from './claude_live_common.mjs'
+
+const argv = parseArgs(process.argv.slice(2))
+const runtimeDir = argv['runtime-dir']
+const turnTimeoutMs = Number.parseInt(argv['timeout-ms'] || String(DEFAULT_TURN_TIMEOUT_MS), 10)
+const retryOnLimit = argv['retry-on-limit'] !== '0'
+const hasPromptInput = Boolean(argv['prompt-file'] || Object.hasOwn(argv, 'prompt') || argv['prompt-stdin'] === '1' || process.stdin.isTTY === false)
+
+if (!runtimeDir || !hasPromptInput) {
+  emitFailure('claude_live_turn_invalid_args', 'Missing required turn arguments', {
+    state_file: runtimeDir ? buildRuntimePaths(runtimeDir).stateFile : null,
+  })
+  process.exit(1)
+}
+
+const paths = buildRuntimePaths(runtimeDir)
+let prompt = ''
+
+function emitTurnFailure(resultPayload) {
+  emitFailure(resultPayload.code, resultPayload.msg, {
+    sid: resultPayload.sid || null,
+    result_file: argv['result-file'] || paths.resultFile,
+    state_file: paths.stateFile,
+  })
+}
+
+try {
+  let promptSource = null
+  let promptSourceKind = null
+
+  const state = await readState(runtimeDir)
+  if (!state) {
+    const resultPayload = buildFailureResult('claude_live_turn_uninitialized', 'Claude live lane is not initialized')
+    emitTurnFailure(resultPayload)
+    process.exit(1)
+  }
+
+  if (state.status !== 'idle') {
+    const resultPayload = buildFailureResult('claude_live_turn_not_idle', `Claude live lane is not idle: ${state.status}`, state.sid || null)
+    emitTurnFailure(resultPayload)
+    process.exit(1)
+  }
+
+  if (!state.sid) {
+    const resultPayload = buildFailureResult('claude_live_turn_unregistered', 'Claude live lane does not have a session id yet')
+    emitTurnFailure(resultPayload)
+    process.exit(1)
+  }
+
+  if (!await tmuxHasSession(state.tmux_session)) {
+    await writeState(runtimeDir, {
+      status: 'failed',
+      last_error: 'Claude tmux session is no longer running',
+    })
+    const resultPayload = buildFailureResult('claude_session_dead', 'Claude tmux session is no longer running', state.sid)
+    emitTurnFailure(resultPayload)
+    process.exit(1)
+  }
+
+  ({ prompt, promptSource, promptSourceKind } = await readPromptInput(argv))
+  let hookStartIndex = (await readJsonl(paths.hookEventsFile)).length
+  const turnNumber = Number(state.last_turn_number || 0)
+  const turnId = buildTurnId(turnNumber)
+
+  await writeState(runtimeDir, {
+    status: 'running',
+    current_turn_id: turnId,
+    current_turn_prompt_file: promptSourceKind === 'file' && promptSource ? promptSource : null,
+    current_turn_prompt_source: promptSource,
+    current_turn_started_at: new Date().toISOString(),
+    last_error: null,
+  })
+
+  while (true) {
+    const liveState = await readState(runtimeDir) || state
+
+    await waitForChannelReady(paths, 15000)
+
+    const sendResult = await postPromptToChannel({
+      state: liveState,
+      prompt,
+      turnId,
+    })
+
+    if (sendResult.statusCode !== 200) {
+      const resultPayload = buildFailureResult('channel_send_failed', sendResult.body || `Channel send failed with status ${sendResult.statusCode}`, liveState.sid || state.sid)
+      await writeTurnArtifacts(paths, turnId, prompt, resultPayload, argv['result-file'] || null)
+      await writeState(runtimeDir, {
+        status: 'failed',
+        current_turn_id: null,
+        current_turn_prompt_file: null,
+        current_turn_prompt_source: null,
+        current_turn_started_at: null,
+        last_completed_turn_id: turnId,
+        last_turn_number: turnNumber + 1,
+        last_error: resultPayload.msg,
+        rate_limit_wait_started_at: null,
+        rate_limit_wait_until: null,
+        rate_limit_wait_ms: null,
+        rate_limit_wait_source: null,
+        rate_limit_message: null,
+        rate_limit_reset_at: null,
+        rate_limit_type: null,
+        rate_limit_raw_reset_at: null,
+      })
+      emitTurnFailure(resultPayload)
+      process.exit(1)
+    }
+
+    const { event, eventsLength } = await waitForHookEvent(paths, hookStartIndex, new Set(['Stop', 'StopFailure']), turnTimeoutMs)
+    hookStartIndex = eventsLength
+
+    if (event.label === 'Stop') {
+      const sessionId = event.payload?.session_id || liveState.sid || state.sid
+      const resultPayload = {
+        ok: true,
+        sid: sessionId,
+        res: event.payload?.last_assistant_message || '',
+      }
+      await writeTurnArtifacts(paths, turnId, prompt, resultPayload, argv['result-file'] || null)
+      await writeState(runtimeDir, {
+        status: 'idle',
+        sid: sessionId,
+        transcript_path: event.payload?.transcript_path || liveState.transcript_path || state.transcript_path || null,
+        current_turn_id: null,
+        current_turn_prompt_file: null,
+        current_turn_prompt_source: null,
+        current_turn_started_at: null,
+        last_completed_turn_id: turnId,
+        last_hook_event: 'Stop',
+        last_error: null,
+        last_turn_number: turnNumber + 1,
+        last_result_summary: resultPayload.res.slice(0, 500),
+        rate_limit_wait_started_at: null,
+        rate_limit_wait_until: null,
+        rate_limit_wait_ms: null,
+        rate_limit_wait_source: null,
+        rate_limit_message: null,
+        rate_limit_reset_at: null,
+        rate_limit_type: null,
+        rate_limit_raw_reset_at: null,
+      })
+      emitSuccess(sessionId, {
+        result_file: argv['result-file'] || paths.resultFile,
+        state_file: paths.stateFile,
+      })
+      process.exit(0)
+    }
+
+    const { result: resultPayload, nextStatus } = classifyStopFailure(event, liveState.sid || state.sid)
+    if (resultPayload.code === 'claude_usage_limit' && retryOnLimit) {
+      await writeState(runtimeDir, {
+        status: 'blocked',
+        sid: resultPayload.sid || liveState.sid || state.sid,
+        transcript_path: event.payload?.transcript_path || liveState.transcript_path || state.transcript_path || null,
+        last_hook_event: 'StopFailure',
+        last_error: resultPayload.msg,
+      })
+      await waitForRateLimitReset({
+        message: resultPayload.detail || resultPayload.msg,
+        resetAt: resultPayload.rate_limit?.resetAt || null,
+        rateLimitType: resultPayload.rate_limit?.rateLimitType || null,
+        rawResetAt: resultPayload.rate_limit?.rawResetAt ?? null,
+        statePath: paths.stateFile,
+      })
+
+      if (!await tmuxHasSession((await readState(runtimeDir))?.tmux_session || liveState.tmux_session)) {
+        const deadPayload = buildFailureResult('claude_session_dead', 'Claude tmux session is no longer running', resultPayload.sid || liveState.sid || state.sid)
+        await writeTurnArtifacts(paths, turnId, prompt, deadPayload, argv['result-file'] || null)
+        await writeState(runtimeDir, {
+          status: 'failed',
+          current_turn_id: null,
+          current_turn_prompt_file: null,
+          current_turn_prompt_source: null,
+          current_turn_started_at: null,
+          last_completed_turn_id: turnId,
+          last_turn_number: turnNumber + 1,
+          last_error: deadPayload.msg,
+          rate_limit_wait_started_at: null,
+          rate_limit_wait_until: null,
+          rate_limit_wait_ms: null,
+          rate_limit_wait_source: null,
+          rate_limit_message: null,
+          rate_limit_reset_at: null,
+          rate_limit_type: null,
+          rate_limit_raw_reset_at: null,
+        })
+        emitTurnFailure(deadPayload)
+        process.exit(1)
+      }
+
+      await writeState(runtimeDir, {
+        status: 'running',
+        current_turn_id: turnId,
+        current_turn_prompt_file: promptSourceKind === 'file' && promptSource ? promptSource : null,
+        current_turn_prompt_source: promptSource,
+        current_turn_started_at: new Date().toISOString(),
+        last_error: null,
+      })
+      continue
+    }
+
+    await writeTurnArtifacts(paths, turnId, prompt, resultPayload, argv['result-file'] || null)
+    await writeState(runtimeDir, {
+      status: nextStatus,
+      sid: resultPayload.sid || liveState.sid || state.sid,
+      transcript_path: event.payload?.transcript_path || liveState.transcript_path || state.transcript_path || null,
+      current_turn_id: null,
+      current_turn_prompt_file: null,
+      current_turn_prompt_source: null,
+      current_turn_started_at: null,
+      last_completed_turn_id: turnId,
+      last_hook_event: 'StopFailure',
+      last_error: resultPayload.msg,
+      last_turn_number: turnNumber + 1,
+      rate_limit_wait_started_at: null,
+      rate_limit_wait_until: null,
+      rate_limit_wait_ms: null,
+      rate_limit_wait_source: null,
+      rate_limit_message: null,
+      rate_limit_reset_at: null,
+      rate_limit_type: null,
+      rate_limit_raw_reset_at: null,
+    })
+    emitTurnFailure(resultPayload)
+    process.exit(1)
+  }
+} catch (error) {
+  const state = await readState(runtimeDir)
+  const code = state?.tmux_session && !await tmuxHasSession(state.tmux_session) ? 'claude_session_dead' : 'claude_bridge_timeout'
+  const resultPayload = buildFailureResult(code, error instanceof Error ? error.message : String(error), state?.sid || null)
+  const turnNumber = Number(state?.last_turn_number || 0)
+  const turnId = buildTurnId(turnNumber)
+  const promptForArtifacts = prompt || await readPromptInput(argv).then((value) => value.prompt).catch(() => '')
+  await writeTurnArtifacts(paths, turnId, promptForArtifacts, resultPayload, argv['result-file'] || null)
+  await writeState(runtimeDir, {
+    status: 'failed',
+    current_turn_id: null,
+    current_turn_prompt_file: null,
+    current_turn_prompt_source: null,
+    current_turn_started_at: null,
+    last_completed_turn_id: turnId,
+    last_turn_number: turnNumber + 1,
+    last_error: resultPayload.msg,
+    rate_limit_wait_started_at: null,
+    rate_limit_wait_until: null,
+    rate_limit_wait_ms: null,
+    rate_limit_wait_source: null,
+    rate_limit_message: null,
+    rate_limit_reset_at: null,
+    rate_limit_type: null,
+    rate_limit_raw_reset_at: null,
+  })
+  emitTurnFailure(resultPayload)
+  process.exit(1)
+}

package/assets/slopmachine/utils/claude_resume_session.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
-import { parseArgs, readPrompt, buildResumeArgs, emitFailure, emitSuccess, compactClaudeResult, runClaudeWithRetry, writeJsonIfNeeded } from './claude_worker_common.mjs'
+import { parseArgs, readPromptInput, buildResumeArgs, emitFailure, emitSuccess, compactClaudeResult, runClaudeWithRetry, writeJsonIfNeeded } from './claude_worker_common.mjs'
 
 const argv = parseArgs(process.argv.slice(2))
 
 try {
-  const prompt = await readPrompt(argv['prompt-file'])
+  const { prompt } = await readPromptInput(argv)
   const { parsed, failure } = await runClaudeWithRetry({
     claudeCommand: argv['claude-command'] || 'claude',
     cwd: argv.cwd,
@@ -22,6 +22,7 @@ try {
       ok: false,
       code: failure?.code || 'claude_resume_failed',
       msg: failure?.msg || 'claude_resume_failed',
+      detail: failure?.detail || null,
       sid: failure?.sid || null,
     }
     await writeJsonIfNeeded(argv['result-file'], resultPayload)

package/assets/slopmachine/utils/claude_wait_for_rate_limit_reset.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { emitFailure, emitSuccess, parseArgs, waitForRateLimitReset } from './claude_worker_common.mjs'
+
+const argv = parseArgs(process.argv.slice(2))
+
+try {
+  const waitInfo = await waitForRateLimitReset({
+    message: argv.message || '',
+    statePath: argv['state-file'] || null,
+    dryRun: argv['dry-run'] === '1',
+    bufferMs: argv['buffer-ms'] ? Number.parseInt(argv['buffer-ms'], 10) : undefined,
+  })
+
+  emitSuccess(null, {
+    wait_ms: waitInfo.waitMs,
+    reset_at: waitInfo.resetAt.toISOString(),
+    source: waitInfo.source,
+  })
+} catch (error) {
+  emitFailure('claude_wait_for_rate_limit_reset_failed', error instanceof Error ? error.message : String(error))
+  process.exitCode = 1
+}

package/assets/slopmachine/utils/claude_wait_for_rate_limit_reset.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+exec node "$SCRIPT_DIR/claude_wait_for_rate_limit_reset.mjs" "$@"