theslopmachine 0.6.2 → 0.7.0

package/assets/slopmachine/utils/claude_live_turn.mjs

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+
+import path from 'node:path'
+
+import {
+  DEFAULT_TURN_TIMEOUT_MS,
+  buildFailureResult,
+  buildRuntimePaths,
+  buildTurnId,
+  classifyStopFailure,
+  emitFailure,
+  emitSuccess,
+  postPromptToChannel,
+  parseArgs,
+  readJsonl,
+  readPrompt,
+  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 promptFile = argv['prompt-file']
+const turnTimeoutMs = Number.parseInt(argv['timeout-ms'] || String(DEFAULT_TURN_TIMEOUT_MS), 10)
+const retryOnLimit = argv['retry-on-limit'] !== '0'
+
+if (!runtimeDir || !promptFile) {
+  emitFailure('claude_live_turn_invalid_args', 'Missing required turn arguments', {
+    state_file: runtimeDir ? buildRuntimePaths(runtimeDir).stateFile : null,
+  })
+  process.exit(1)
+}
+
+const paths = buildRuntimePaths(runtimeDir)
+
+function emitTurnFailure(resultPayload) {
+  emitFailure(resultPayload.code, resultPayload.msg, {
+    sid: resultPayload.sid || null,
+    result_file: argv['result-file'] || paths.resultFile,
+    state_file: paths.stateFile,
+  })
+}
+
+try {
+  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)
+  }
+
+  const prompt = await readPrompt(promptFile)
+  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: path.resolve(promptFile),
+    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_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,
+      })
+      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_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,
+      })
+      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,
+        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_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,
+        })
+        emitTurnFailure(deadPayload)
+        process.exit(1)
+      }
+
+      await writeState(runtimeDir, {
+        status: 'running',
+        current_turn_id: turnId,
+        current_turn_prompt_file: path.resolve(promptFile),
+        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_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,
+    })
+    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 prompt = await readPrompt(promptFile).catch(() => '')
+  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_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,
+  })
+  emitTurnFailure(resultPayload)
+  process.exit(1)
+}

package/assets/slopmachine/utils/claude_resume_session.mjs

@@ -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" "$@"

package/assets/slopmachine/utils/claude_worker_common.mjs

@@ -5,10 +5,16 @@ import { createWriteStream } from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
 
-const DEFAULT_ALLOWED_TOOLS = ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep']
+const DEFAULT_ALLOWED_TOOLS = ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'Task', 'TaskOutput', 'TaskStop']
 const DEFAULT_LIMIT_TIMEZONE = 'Africa/Addis_Ababa'
 const DEFAULT_LIMIT_HOUR = 5
+const DEFAULT_RATE_LIMIT_BUFFER_MS = 60 * 1000
+
+function utilsDir() {
+  return path.dirname(fileURLToPath(import.meta.url))
+}
 
 export function parseArgs(argv) {
   const result = {}
@@ -39,6 +45,17 @@ export async function writeJsonIfNeeded(filePath, value) {
   await writeFileIfNeeded(filePath, `${JSON.stringify(value, null, 2)}\n`)
 }
 
+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 readJsonFile(filePath) {
   const content = await fs.readFile(filePath, 'utf8')
   return JSON.parse(content)
@@ -236,6 +253,7 @@ export function classifyClaudeFailure(parsed, fallbackMessage = '') {
     return {
       code: 'claude_usage_limit',
       msg: 'usage_limit',
+      detail: rawMessage,
       retryable: true,
       sid: sessionId,
     }
@@ -245,6 +263,7 @@ export function classifyClaudeFailure(parsed, fallbackMessage = '') {
     return {
       code: 'claude_transport_failed',
       msg: rawMessage || 'claude_transport_failed',
+      detail: rawMessage || 'claude_transport_failed',
       retryable: true,
       sid: sessionId,
     }
@@ -253,11 +272,210 @@ export function classifyClaudeFailure(parsed, fallbackMessage = '') {
   return {
     code: 'claude_call_failed',
     msg: rawMessage || 'claude_call_failed',
+    detail: rawMessage || 'claude_call_failed',
     retryable: false,
     sid: sessionId,
   }
 }
 
+function normalizeOffset(token) {
+  if (!token) return null
+  const normalized = token.trim().toUpperCase()
+  if (normalized === 'Z' || normalized === 'UTC' || normalized === 'GMT') {
+    return 'Z'
+  }
+  if (/^[+-]\d{2}:?\d{2}$/.test(normalized)) {
+    return normalized.includes(':') ? normalized : `${normalized.slice(0, 3)}:${normalized.slice(3)}`
+  }
+  return null
+}
+
+function getDatePartsForOffset(now, offsetToken) {
+  const offsetMinutes = offsetToken === 'Z'
+    ? 0
+    : Number(offsetToken.slice(1, 3)) * 60 + Number(offsetToken.slice(4, 6))
+  const signedOffsetMinutes = offsetToken.startsWith('-') ? -offsetMinutes : offsetMinutes
+  const shifted = new Date(now.getTime() + signedOffsetMinutes * 60 * 1000)
+  return {
+    year: shifted.getUTCFullYear(),
+    month: shifted.getUTCMonth() + 1,
+    day: shifted.getUTCDate(),
+    offsetToken,
+  }
+}
+
+function buildIsoFromParts({ year, month, day }, hours, minutes, offsetToken) {
+  const paddedMonth = String(month).padStart(2, '0')
+  const paddedDay = String(day).padStart(2, '0')
+  const paddedHours = String(hours).padStart(2, '0')
+  const paddedMinutes = String(minutes).padStart(2, '0')
+  return `${year}-${paddedMonth}-${paddedDay}T${paddedHours}:${paddedMinutes}:00${offsetToken}`
+}
+
+function parseTimeOnlyCandidate(candidate, now) {
+  const match = candidate.match(/\b(today|tomorrow)?\s*(\d{1,2})(?::(\d{2}))?\s*(am|pm)?(?:\s*(UTC|GMT|Z|[+-]\d{2}:?\d{2}))?\b/i)
+  if (!match) {
+    return null
+  }
+
+  const dayWord = match[1]?.toLowerCase() || null
+  let hours = Number(match[2])
+  const minutes = Number(match[3] || '0')
+  const meridiem = match[4]?.toLowerCase() || null
+  const offsetToken = normalizeOffset(match[5] || null)
+
+  if (meridiem) {
+    if (hours === 12) hours = 0
+    if (meridiem === 'pm') hours += 12
+  }
+
+  if (offsetToken) {
+    let dateParts = getDatePartsForOffset(now, offsetToken)
+    let parsed = Date.parse(buildIsoFromParts(dateParts, hours, minutes, offsetToken))
+    if (Number.isNaN(parsed)) {
+      return null
+    }
+    if (dayWord === 'tomorrow' || (dayWord !== 'today' && parsed <= now.getTime())) {
+      const retryBase = new Date(parsed + 24 * 60 * 60 * 1000)
+      dateParts = { year: retryBase.getUTCFullYear(), month: retryBase.getUTCMonth() + 1, day: retryBase.getUTCDate(), offsetToken }
+      parsed = Date.parse(buildIsoFromParts(dateParts, hours, minutes, offsetToken))
+    }
+    return Number.isNaN(parsed) ? null : new Date(parsed)
+  }
+
+  const target = new Date(now)
+  target.setSeconds(0, 0)
+  target.setHours(hours, minutes, 0, 0)
+  if (dayWord === 'tomorrow') {
+    target.setDate(target.getDate() + 1)
+  } else if (dayWord !== 'today' && target.getTime() <= now.getTime()) {
+    target.setDate(target.getDate() + 1)
+  }
+  return target
+}
+
+function parseRelativeWait(candidate, now) {
+  const lowered = candidate.toLowerCase()
+  const anchorMatch = lowered.match(/(?:in|after)\s+([^\n]+)/)
+  if (!anchorMatch) {
+    return null
+  }
+  const fragment = anchorMatch[1]
+  const regex = /(\d+)\s*(milliseconds?|ms|seconds?|secs?|minutes?|mins?|hours?|hrs?)/g
+  let totalMs = 0
+  let hasMatch = false
+  for (const match of fragment.matchAll(regex)) {
+    hasMatch = true
+    const amount = Number(match[1])
+    const unit = match[2].toLowerCase()
+    if (unit.startsWith('ms')) totalMs += amount
+    else if (unit.startsWith('second') || unit.startsWith('sec')) totalMs += amount * 1000
+    else if (unit.startsWith('minute') || unit.startsWith('min')) totalMs += amount * 60 * 1000
+    else if (unit.startsWith('hour') || unit.startsWith('hr')) totalMs += amount * 60 * 60 * 1000
+  }
+  if (!hasMatch || totalMs <= 0) {
+    return null
+  }
+  return new Date(now.getTime() + totalMs)
+}
+
+function parseAbsoluteCandidate(candidate, now) {
+  const cleaned = candidate
+    .replace(/^[:\s-]+/, '')
+    .replace(/[).,;]+$/g, '')
+    .trim()
+  if (!cleaned) {
+    return null
+  }
+
+  const direct = Date.parse(cleaned)
+  if (!Number.isNaN(direct)) {
+    const parsed = new Date(direct)
+    if (parsed.getTime() > now.getTime()) {
+      return parsed
+    }
+  }
+
+  return parseTimeOnlyCandidate(cleaned, now)
+}
+
+export function calculateRateLimitReset({ message, now = new Date(), bufferMs = DEFAULT_RATE_LIMIT_BUFFER_MS } = {}) {
+  const rawMessage = String(message || '').trim()
+  if (!rawMessage) {
+    const fallbackMs = msUntilNextQuotaReset(now)
+    return {
+      waitMs: Math.max(fallbackMs + bufferMs, 0),
+      resetAt: new Date(now.getTime() + fallbackMs),
+      source: 'fallback_default_quota_window',
+      rawMessage,
+    }
+  }
+
+  const relative = parseRelativeWait(rawMessage, now)
+  if (relative) {
+    return {
+      waitMs: Math.max(relative.getTime() - now.getTime() + bufferMs, 0),
+      resetAt: relative,
+      source: 'relative_duration',
+      rawMessage,
+    }
+  }
+
+  const phraseRegex = /(?:reset(?:s| time)?|try again|available|wait)\s+(?:at|until|on)?\s*([^\n]+)/ig
+  for (const match of rawMessage.matchAll(phraseRegex)) {
+    const parsed = parseAbsoluteCandidate(match[1], now)
+    if (parsed) {
+      return {
+        waitMs: Math.max(parsed.getTime() - now.getTime() + bufferMs, 0),
+        resetAt: parsed,
+        source: 'anchored_phrase',
+        rawMessage,
+      }
+    }
+  }
+
+  const isoRegex = /\b\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})\b/g
+  for (const match of rawMessage.matchAll(isoRegex)) {
+    const parsed = parseAbsoluteCandidate(match[0], now)
+    if (parsed) {
+      return {
+        waitMs: Math.max(parsed.getTime() - now.getTime() + bufferMs, 0),
+        resetAt: parsed,
+        source: 'iso_datetime',
+        rawMessage,
+      }
+    }
+  }
+
+  const fallbackMs = msUntilNextQuotaReset(now)
+  return {
+    waitMs: Math.max(fallbackMs + bufferMs, 0),
+    resetAt: new Date(now.getTime() + fallbackMs),
+    source: 'fallback_default_quota_window',
+    rawMessage,
+  }
+}
+
+export async function waitForRateLimitReset({ message, statePath = null, dryRun = false, bufferMs = DEFAULT_RATE_LIMIT_BUFFER_MS } = {}) {
+  const waitInfo = calculateRateLimitReset({ message, bufferMs })
+  if (statePath) {
+    const existing = (await readJsonIfExists(statePath)) || {}
+    await writeJsonIfNeeded(statePath, {
+      ...existing,
+      status: 'blocked',
+      rate_limit_wait_started_at: new Date().toISOString(),
+      rate_limit_wait_until: waitInfo.resetAt.toISOString(),
+      rate_limit_wait_ms: waitInfo.waitMs,
+      rate_limit_wait_source: waitInfo.source,
+      rate_limit_message: waitInfo.rawMessage || null,
+    })
+  }
+  if (!dryRun && waitInfo.waitMs > 0) {
+    await sleep(waitInfo.waitMs)
+  }
+  return waitInfo
+}
+
 function getZonedParts(date, timeZone) {
   const formatter = new Intl.DateTimeFormat('en-CA', {
     timeZone,
@@ -288,7 +506,7 @@ export function msUntilNextQuotaReset(now = new Date(), { hour = DEFAULT_LIMIT_H
   if (waitMs <= 0) {
     waitMs += 24 * 60 * 60 * 1000
   }
-  return waitMs + 60 * 1000
+  return waitMs
 }
 
 export async function runClaudeWithRetry({ claudeCommand, args, cwd, rawOutputPath, rawErrorPath, statePath, retryOnLimit = true, maxAttempts = 2 }) {
@@ -322,8 +540,10 @@ export async function runClaudeWithRetry({ claudeCommand, args, cwd, rawOutputPa
     }
 
     if (failure.code === 'claude_usage_limit' && retryOnLimit) {
-      const waitMs = msUntilNextQuotaReset()
-      await sleep(waitMs)
+      await waitForRateLimitReset({
+        message: failure.detail || failure.msg,
+        statePath,
+      })
     }
 
     attempt += 1

package/assets/slopmachine/utils/cleanup_delivery_artifacts.py

@@ -13,10 +13,12 @@ KNOWN_DIR_NAMES = {
     '.parcel-cache',
     '.pytest_cache',
     '.svelte-kit',
+    '.venv',
     '.tmp',
     '.turbo',
     '.vite',
     '.vscode',
+    '.net',
     '__pycache__',
     'build',
     'coverage',
@@ -38,6 +40,8 @@ JAVA_BUILD_MARKERS = {
 }
 
 KNOWN_FILE_NAMES = {
+    'AGENTS.md',
+    'CLAUDE.md',
     '.DS_Store',
     '.env',
     '.env.development',

package/assets/slopmachine/utils/export_ai_session.mjs

@@ -22,7 +22,7 @@ async function run(command, args, cwd) {
 
 try {
   await fs.mkdir(path.dirname(argv.output), { recursive: true })
-  if (argv.backend === 'claude') {
+  if (argv.backend === 'claude' || argv.backend === 'claude-live') {
     const sourcePath = await resolveClaudeSessionPath(argv['session-id'], argv.cwd)
     const content = await fs.readFile(sourcePath, 'utf8')
     await fs.writeFile(argv.output, content, 'utf8')