theslopmachine 0.6.2 → 0.7.1

package/assets/slopmachine/utils/claude_live_channel.mjs

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+
+import http from 'node:http'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import { parseArgs, writeJsonIfNeeded } from './claude_worker_common.mjs'
+
+const argv = parseArgs(process.argv.slice(2))
+const port = Number.parseInt(argv.port, 10)
+const token = argv.token
+const stateFile = argv['state-file']
+const logFile = argv['log-file']
+const channelName = argv['channel-name'] || 'slopmachine-channel'
+const lane = argv.lane || 'lane'
+
+const instructions = 'Messages arrive as <channel source="slopmachine" ...>. Treat them as ordinary inbound work requests and respond normally in the current Claude session. Do not look for or use any reply tool for this channel.'
+
+let buffer = ''
+let readyForNotifications = false
+let negotiatedProtocolVersion = '2025-11-25'
+
+function writeMessage(message) {
+  process.stdout.write(`${JSON.stringify(message)}\n`)
+}
+
+async function appendLog(record) {
+  const line = `${JSON.stringify({ ts: new Date().toISOString(), ...record })}\n`
+  await fs.mkdir(path.dirname(logFile), { recursive: true })
+  await fs.appendFile(logFile, line, 'utf8')
+}
+
+async function updateState(patch) {
+  await writeJsonIfNeeded(stateFile, {
+    channel_name: channelName,
+    lane,
+    pid: process.pid,
+    port,
+    ready_for_notifications: readyForNotifications,
+    protocol_version: negotiatedProtocolVersion,
+    updated_at: new Date().toISOString(),
+    ...patch,
+  })
+}
+
+async function handleRpc(message) {
+  if (message.method === 'initialize' && Object.prototype.hasOwnProperty.call(message, 'id')) {
+    negotiatedProtocolVersion = message.params?.protocolVersion || negotiatedProtocolVersion
+    await updateState({ status: 'initialized' })
+    writeMessage({
+      jsonrpc: '2.0',
+      id: message.id,
+      result: {
+        protocolVersion: negotiatedProtocolVersion,
+        capabilities: {
+          experimental: {
+            'claude/channel': {},
+          },
+        },
+        serverInfo: {
+          name: channelName,
+          version: '0.1.0',
+        },
+        instructions,
+      },
+    })
+    await appendLog({ type: 'initialize', message })
+    return
+  }
+
+  if (message.method === 'notifications/initialized') {
+    readyForNotifications = true
+    await updateState({ status: 'ready' })
+    await appendLog({ type: 'initialized' })
+    return
+  }
+
+  if (message.method === 'ping' && Object.prototype.hasOwnProperty.call(message, 'id')) {
+    writeMessage({ jsonrpc: '2.0', id: message.id, result: {} })
+    return
+  }
+
+  if (Object.prototype.hasOwnProperty.call(message, 'id')) {
+    writeMessage({
+      jsonrpc: '2.0',
+      id: message.id,
+      error: {
+        code: -32601,
+        message: `Method not found: ${message.method}`,
+      },
+    })
+  }
+}
+
+process.stdin.setEncoding('utf8')
+process.stdin.on('data', async (chunk) => {
+  buffer += chunk
+  while (true) {
+    const newlineIndex = buffer.indexOf('\n')
+    if (newlineIndex === -1) {
+      break
+    }
+    const line = buffer.slice(0, newlineIndex).trim()
+    buffer = buffer.slice(newlineIndex + 1)
+    if (!line) {
+      continue
+    }
+    try {
+      const message = JSON.parse(line)
+      await handleRpc(message)
+    } catch (error) {
+      await updateState({ status: 'failed', last_error: error instanceof Error ? error.message : String(error) })
+      await appendLog({ type: 'rpc_error', error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+})
+
+process.stdin.on('end', async () => {
+  await updateState({ status: 'closed' })
+  process.exit(0)
+})
+
+await updateState({ status: 'starting' })
+
+const server = http.createServer(async (request, response) => {
+  if (request.method !== 'POST') {
+    response.writeHead(404)
+    response.end('not found')
+    return
+  }
+
+  if (request.headers['x-bridge-token'] !== token) {
+    response.writeHead(403)
+    response.end('forbidden')
+    return
+  }
+
+  if (!readyForNotifications) {
+    response.writeHead(503)
+    response.end('channel_not_ready')
+    return
+  }
+
+  let body = ''
+  for await (const chunk of request) {
+    body += chunk.toString()
+  }
+
+  const turnId = String(request.headers['x-turn-id'] || '').trim()
+  const notification = {
+    jsonrpc: '2.0',
+    method: 'notifications/claude/channel',
+    params: {
+      content: body,
+      meta: {
+        lane,
+        turn_id: turnId,
+        method: request.method,
+      },
+    },
+  }
+
+  writeMessage(notification)
+  await updateState({ status: 'ready', last_message_at: new Date().toISOString(), last_turn_id: turnId || null })
+  await appendLog({ type: 'notification', turn_id: turnId || null, body })
+  response.writeHead(200)
+  response.end('ok')
+})
+
+server.listen(port, '127.0.0.1', async () => {
+  await updateState({ status: 'listening' })
+  await appendLog({ type: 'listening' })
+})
+
+async function shutdown(code) {
+  await updateState({ status: 'closed' })
+  server.close(() => {
+    process.exit(code)
+  })
+}
+
+process.on('SIGINT', () => {
+  void shutdown(0)
+})
+
+process.on('SIGTERM', () => {
+  void shutdown(0)
+})

package/assets/slopmachine/utils/claude_live_common.mjs

@@ -0,0 +1,411 @@
+#!/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, extractRateLimitMetadata, 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, effort = null }) {
+  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))
+  }
+
+  if (effort) {
+    parts.push('--effort', shellQuote(effort))
+  }
+
+  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'
+  const rateLimit = extractRateLimitMetadata(payload)
+
+  if (/hit your limit|usage limit|capacity|overloaded/i.test(message)) {
+    return {
+      result: { ok: false, code: 'claude_usage_limit', msg: 'usage_limit', detail: message, rate_limit: rateLimit, 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()