@the-open-engine/zeroshot 5.4.0

package/task-lib/attachable-watcher.js

@@ -0,0 +1,381 @@
+#!/usr/bin/env node
+
+/**
+ * Attachable Watcher - spawns a CLI process with PTY for attach/detach support
+ * Runs detached from parent, provides Unix socket for attach clients.
+ */
+
+import { appendFileSync, existsSync, mkdirSync, unlinkSync } from 'fs';
+import { unlink } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+import { updateTask } from './store.js';
+import {
+  detectProviderFatalError,
+  detectProviderStreamingModeError,
+  recoverProviderStructuredOutput,
+  supportsProviderStructuredOutputRecovery,
+} from './provider-helper-runtime.js';
+import { createRequire } from 'module';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 🔴 CRITICAL: Global error handlers - MUST be installed BEFORE any async ops
+// Without these, uncaught errors cause SILENT process death (no logs, no status)
+// ═══════════════════════════════════════════════════════════════════════════
+
+const [, , taskIdArg, cwdArg, logFileArg, argsJsonArg, configJsonArg] = process.argv;
+let commandSpecCleanup = [];
+let cleanupStarted = false;
+
+function emergencyLog(msg) {
+  if (logFileArg) {
+    try {
+      appendFileSync(logFileArg, msg);
+    } catch {
+      process.stderr.write(msg);
+    }
+  } else {
+    process.stderr.write(msg);
+  }
+}
+
+function crashWithError(error, source) {
+  const timestamp = Date.now();
+  const errorMsg = error instanceof Error ? error.stack || error.message : String(error);
+
+  emergencyLog(`\n[${timestamp}][CRASH] ${source}: ${errorMsg}\n`);
+  emergencyLog(`[${timestamp}][CRASH] Process terminating due to unhandled error\n`);
+  cleanupCommandSpecSync();
+
+  if (taskIdArg) {
+    try {
+      updateTask(taskIdArg, {
+        status: 'failed',
+        error: `${source}: ${errorMsg}`,
+        socketPath: null,
+      });
+    } catch (updateError) {
+      emergencyLog(`[${timestamp}][CRASH] Failed to update task status: ${updateError.message}\n`);
+    }
+  }
+
+  process.exit(1);
+}
+
+process.on('uncaughtException', (error) => {
+  crashWithError(error, 'uncaughtException');
+});
+
+process.on('unhandledRejection', (reason) => {
+  crashWithError(reason, 'unhandledRejection');
+});
+
+const require = createRequire(import.meta.url);
+const { AttachServer } = require('../src/attach');
+const { normalizeProviderName } = require('../lib/provider-names');
+
+const taskId = taskIdArg;
+const cwd = cwdArg;
+const logFile = logFileArg;
+const args = JSON.parse(argsJsonArg);
+const config = configJsonArg ? JSON.parse(configJsonArg) : {};
+const commandSpec = config.commandSpec || {
+  binary: config.command || 'claude',
+  args,
+  env: config.env || {},
+  cleanup: [],
+};
+commandSpecCleanup = commandSpec.cleanup || [];
+let server = null;
+
+const SOCKET_DIR = join(homedir(), '.zeroshot', 'sockets');
+const socketPath = join(SOCKET_DIR, `${taskId}.sock`);
+
+if (!existsSync(SOCKET_DIR)) {
+  mkdirSync(SOCKET_DIR, { recursive: true });
+}
+
+function log(msg) {
+  appendFileSync(logFile, msg);
+}
+
+const providerName = normalizeProviderName(config.provider || 'claude');
+const enableRecovery = supportsProviderStructuredOutputRecovery(providerName);
+
+const env = { ...process.env, ...(commandSpec.env || {}) };
+const command = commandSpec.binary;
+const finalArgs = [...(commandSpec.args || args)];
+
+const silentJsonMode =
+  config.outputFormat === 'json' &&
+  config.jsonSchema &&
+  config.silentJsonOutput &&
+  supportsProviderStructuredOutputRecovery(providerName);
+
+let finalResultJson = null;
+let outputBuffer = '';
+let streamingModeError = null;
+let fatalError = null;
+
+function splitBufferLines(buffer, chunk) {
+  const nextBuffer = buffer + chunk;
+  const lines = nextBuffer.split('\n');
+  const remaining = lines.pop() || '';
+  return { lines, remaining };
+}
+
+function maybeHandleFatalError(line, timestamp) {
+  if (fatalError) {
+    return false;
+  }
+
+  const detected = detectProviderFatalError(providerName, line);
+  if (!detected) {
+    return false;
+  }
+
+  fatalError = detected;
+
+  if (silentJsonMode) {
+    log(`[${timestamp}]${line}\n`);
+  }
+  log(`[${timestamp}][FATAL] ${detected}\n`);
+
+  if (server) {
+    server.stop('SIGTERM').catch((error) => {
+      log(`[${timestamp}][FATAL] Attach server stop failed: ${error.message}\n`);
+    });
+  }
+  return true;
+}
+
+function captureStreamingError(line, timestamp) {
+  const detectedError = detectProviderStreamingModeError(providerName, line);
+  if (!detectedError) {
+    return false;
+  }
+
+  streamingModeError = { ...detectedError, timestamp };
+  return true;
+}
+
+function maybeCaptureStructuredOutput(line) {
+  try {
+    const json = JSON.parse(line);
+    if (json.structured_output) {
+      finalResultJson = line;
+    }
+  } catch {
+    // Not JSON, skip
+  }
+}
+
+function handleSilentJsonLines(lines, timestamp) {
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    maybeHandleFatalError(line, timestamp);
+    if (captureStreamingError(line, timestamp)) {
+      continue;
+    }
+    maybeCaptureStructuredOutput(line);
+  }
+}
+
+function handleStreamingLines(lines, timestamp) {
+  for (const line of lines) {
+    maybeHandleFatalError(line, timestamp);
+    if (captureStreamingError(line, timestamp)) {
+      continue;
+    }
+    log(`[${timestamp}]${line}\n`);
+  }
+}
+
+function flushOutputBuffer(timestamp) {
+  if (!outputBuffer.trim()) {
+    return;
+  }
+
+  if (!enableRecovery) {
+    if (!silentJsonMode) {
+      log(`[${timestamp}]${outputBuffer}\n`);
+    }
+    return;
+  }
+
+  maybeHandleFatalError(outputBuffer, timestamp);
+  if (captureStreamingError(outputBuffer, timestamp)) {
+    return;
+  }
+
+  if (silentJsonMode) {
+    maybeCaptureStructuredOutput(outputBuffer);
+    return;
+  }
+
+  log(`[${timestamp}]${outputBuffer}\n`);
+}
+
+function attemptRecovery(code, timestamp) {
+  if (!(code !== 0 && streamingModeError?.sessionId)) {
+    return null;
+  }
+
+  const recovered = recoverProviderStructuredOutput(providerName, streamingModeError.sessionId);
+  if (recovered?.payload) {
+    const recoveredLine = JSON.stringify(recovered.payload);
+    if (silentJsonMode) {
+      finalResultJson = recoveredLine;
+    } else {
+      log(`[${timestamp}]${recoveredLine}\n`);
+    }
+  } else if (streamingModeError.line) {
+    if (silentJsonMode) {
+      log(streamingModeError.line + '\n');
+    } else {
+      log(`[${streamingModeError.timestamp}]${streamingModeError.line}\n`);
+    }
+  }
+
+  return recovered;
+}
+
+async function cleanupCommandSpec() {
+  if (cleanupStarted) return;
+  cleanupStarted = true;
+  for (const file of commandSpecCleanup) {
+    try {
+      await unlink(file);
+    } catch (error) {
+      log(`[${Date.now()}][CLEANUP] Failed to delete ${file}: ${error.message}\n`);
+    }
+  }
+}
+
+function cleanupCommandSpecSync() {
+  if (cleanupStarted) return;
+  cleanupStarted = true;
+  for (const file of commandSpecCleanup) {
+    try {
+      unlinkSync(file);
+    } catch (error) {
+      emergencyLog(`[${Date.now()}][CLEANUP] Failed to delete ${file}: ${error.message}\n`);
+    }
+  }
+}
+
+function writeCompletionFooter(code, signal) {
+  if (config.outputFormat === 'json') {
+    return;
+  }
+
+  log(`\n${'='.repeat(50)}\n`);
+  log(`Finished: ${new Date().toISOString()}\n`);
+  log(`Exit code: ${code}, Signal: ${signal}\n`);
+}
+
+server = new AttachServer({
+  id: taskId,
+  socketPath,
+  command,
+  args: finalArgs,
+  cwd: commandSpec.cwd || cwd,
+  env,
+  cols: 120,
+  rows: 30,
+});
+
+server.on('output', (data) => {
+  const chunk = data.toString();
+  const timestamp = Date.now();
+
+  const { lines, remaining } = splitBufferLines(outputBuffer, chunk);
+  outputBuffer = remaining;
+
+  if (silentJsonMode) {
+    handleSilentJsonLines(lines, timestamp);
+  } else {
+    handleStreamingLines(lines, timestamp);
+  }
+});
+
+server.on('exit', async ({ exitCode, signal }) => {
+  const timestamp = Date.now();
+  const code = exitCode;
+
+  flushOutputBuffer(timestamp);
+
+  const recovered = attemptRecovery(code, timestamp);
+
+  if (silentJsonMode && finalResultJson) {
+    log(finalResultJson + '\n');
+  }
+
+  writeCompletionFooter(code, signal);
+  await cleanupCommandSpec();
+
+  const resolvedCode = fatalError ? 1 : recovered?.payload ? 0 : code;
+  const status = resolvedCode === 0 ? 'completed' : 'failed';
+  try {
+    await updateTask(taskId, {
+      status,
+      exitCode: resolvedCode,
+      error: fatalError || (resolvedCode !== 0 && signal ? `Killed by ${signal}` : null),
+      socketPath: null,
+    });
+  } catch (updateError) {
+    log(`[${Date.now()}][ERROR] Failed to update task status: ${updateError.message}\n`);
+  }
+
+  setTimeout(() => {
+    process.exit(0);
+  }, 500);
+});
+
+server.on('error', async (err) => {
+  log(`\nError: ${err.message}\n`);
+  await cleanupCommandSpec();
+  try {
+    await updateTask(taskId, { status: 'failed', error: err.message });
+  } catch (updateError) {
+    log(`[${Date.now()}][ERROR] Failed to update task status: ${updateError.message}\n`);
+  }
+  process.exit(1);
+});
+
+server.on('clientAttach', ({ clientId }) => {
+  log(`[${Date.now()}][ATTACH] Client attached: ${clientId.slice(0, 8)}...\n`);
+});
+
+server.on('clientDetach', ({ clientId }) => {
+  log(`[${Date.now()}][DETACH] Client detached: ${clientId.slice(0, 8)}...\n`);
+});
+
+try {
+  await server.start();
+
+  updateTask(taskId, {
+    pid: server.pid,
+    socketPath,
+    attachable: true,
+  });
+
+  log(`[${Date.now()}][SYSTEM] Started with PTY (attachable)\n`);
+  log(`[${Date.now()}][SYSTEM] Socket: ${socketPath}\n`);
+  log(`[${Date.now()}][SYSTEM] PID: ${server.pid}\n`);
+} catch (err) {
+  log(`\nFailed to start: ${err.message}\n`);
+  await cleanupCommandSpec();
+  updateTask(taskId, { status: 'failed', error: err.message });
+  process.exit(1);
+}
+
+process.on('SIGTERM', async () => {
+  log(`[${Date.now()}][SYSTEM] Received SIGTERM, stopping...\n`);
+  await server.stop('SIGTERM');
+});
+
+process.on('SIGINT', async () => {
+  log(`[${Date.now()}][SYSTEM] Received SIGINT, stopping...\n`);
+  await server.stop('SIGINT');
+});

package/task-lib/commands/clean.js

@@ -0,0 +1,50 @@
+import { unlinkSync, existsSync } from 'fs';
+import chalk from 'chalk';
+import { loadTasks, saveTasks } from '../store.js';
+
+export function cleanTasks(options = {}) {
+  const tasks = loadTasks();
+  const taskList = Object.values(tasks);
+
+  if (taskList.length === 0) {
+    console.log(chalk.dim('No tasks to clean.'));
+    return;
+  }
+
+  const toRemove = [];
+
+  for (const task of taskList) {
+    const shouldRemove =
+      options.all ||
+      (options.completed && task.status === 'completed') ||
+      (options.failed &&
+        (task.status === 'failed' || task.status === 'stale' || task.status === 'killed'));
+
+    if (shouldRemove) {
+      toRemove.push(task);
+    }
+  }
+
+  if (toRemove.length === 0) {
+    console.log(chalk.dim('No tasks match the criteria.'));
+    return;
+  }
+
+  console.log(chalk.dim(`Removing ${toRemove.length} task(s)...\n`));
+
+  for (const task of toRemove) {
+    // Delete log file
+    if (task.logFile && existsSync(task.logFile)) {
+      unlinkSync(task.logFile);
+    }
+
+    // Remove from tasks
+    delete tasks[task.id];
+
+    console.log(chalk.dim(`  Removed: ${task.id} [${task.status}]`));
+  }
+
+  saveTasks(tasks);
+
+  console.log(chalk.green(`\n✓ Cleaned ${toRemove.length} task(s)`));
+}

package/task-lib/commands/episodes.js

@@ -0,0 +1,105 @@
+import chalk from 'chalk';
+import { loadTasks } from '../store.js';
+import { isProcessRunning } from '../runner.js';
+
+export function listEpisodes(options = {}) {
+  const tasks = loadTasks();
+  const taskList = Object.values(tasks);
+
+  if (taskList.length === 0) {
+    console.log(chalk.dim('No episodes found.'));
+    return;
+  }
+
+  // Sort by creation date, oldest first (chronological order)
+  taskList.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
+
+  // Filter by status if specified
+  let filtered = taskList;
+  if (options.status) {
+    filtered = taskList.filter((t) => t.status === options.status);
+  }
+
+  // Limit results
+  const limit = options.limit || 20;
+  filtered = filtered.slice(0, limit);
+
+  // Table format (default) or verbose format
+  if (options.verbose) {
+    // Verbose format (old behavior)
+    console.log(chalk.bold(`\nEpisodes (${filtered.length}/${taskList.length})\n`));
+
+    for (const task of filtered) {
+      // Verify running status
+      let status = task.status;
+      if (status === 'running' && !isProcessRunning(task.pid)) {
+        status = 'stale';
+      }
+
+      const statusColor =
+        {
+          running: chalk.green,
+          completed: chalk.green,
+          failed: chalk.red,
+          stale: chalk.yellow,
+        }[status] || chalk.dim;
+
+      const age = getAge(task.createdAt);
+      const timestamp = new Date(task.createdAt).toLocaleString();
+
+      console.log(
+        `${statusColor('●')} ${chalk.cyan(task.id)} ${statusColor(`[${status}]`)} ${chalk.dim(age + ' • ' + timestamp)}`
+      );
+      console.log(`  ${chalk.dim('CWD:')} ${task.cwd}`);
+      console.log(`  ${chalk.dim('Prompt:')} ${task.prompt}`);
+      if (task.pid && status === 'running') {
+        console.log(`  ${chalk.dim('PID:')} ${task.pid}`);
+      }
+      if (task.error) {
+        console.log(`  ${chalk.red('Error:')} ${task.error}`);
+      }
+      console.log();
+    }
+  } else {
+    // Table format (clean, default)
+    console.log(chalk.bold(`\n=== Episodes (${filtered.length}/${taskList.length}) ===`));
+    console.log(`${'ID'.padEnd(25)} ${'Status'.padEnd(12)} ${'Age'.padEnd(10)} CWD`);
+    console.log('-'.repeat(100));
+
+    for (const task of filtered) {
+      // Verify running status
+      let status = task.status;
+      if (status === 'running' && !isProcessRunning(task.pid)) {
+        status = 'stale';
+      }
+
+      const statusColor =
+        {
+          running: chalk.green,
+          completed: chalk.green,
+          failed: chalk.red,
+          stale: chalk.yellow,
+        }[status] || chalk.dim;
+
+      const age = getAge(task.createdAt);
+      const cwd = task.cwd.replace(process.env.HOME, '~');
+
+      console.log(
+        `${chalk.cyan(task.id.padEnd(25))} ${statusColor(status.padEnd(12))} ${chalk.dim(age.padEnd(10))} ${chalk.dim(cwd)}`
+      );
+    }
+    console.log();
+  }
+}
+
+function getAge(dateStr) {
+  const diff = Date.now() - new Date(dateStr).getTime();
+  const mins = Math.floor(diff / 60000);
+  const hours = Math.floor(mins / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (mins > 0) return `${mins}m ago`;
+  return 'just now';
+}

package/task-lib/commands/get-log-path.js

@@ -0,0 +1,23 @@
+import { getTask } from '../store.js';
+
+/**
+ * Get log file path for a task (machine-readable output)
+ * Used by cluster/agent-wrapper.js to follow task logs
+ * @param {string} taskId - Task ID
+ */
+export function getLogPath(taskId) {
+  const task = getTask(taskId);
+
+  if (!task) {
+    console.error(`Task not found: ${taskId}`);
+    process.exit(1);
+  }
+
+  if (!task.logFile) {
+    console.error(`No log file for task: ${taskId}`);
+    process.exit(1);
+  }
+
+  // Output just the path (machine-readable)
+  console.log(task.logFile);
+}

package/task-lib/commands/kill.js

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+import { getTask, updateTask } from '../store.js';
+import { killTask as killProcess, isProcessRunning } from '../runner.js';
+
+export function killTaskCommand(taskId) {
+  const task = getTask(taskId);
+
+  if (!task) {
+    console.log(chalk.red(`Task not found: ${taskId}`));
+    process.exit(1);
+  }
+
+  if (task.status !== 'running') {
+    console.log(chalk.yellow(`Task is not running (status: ${task.status})`));
+    return;
+  }
+
+  if (!isProcessRunning(task.pid)) {
+    console.log(chalk.yellow('Process already dead, updating status...'));
+    updateTask(taskId, { status: 'stale', error: 'Process died unexpectedly' });
+    return;
+  }
+
+  const killed = killProcess(task.pid);
+
+  if (killed) {
+    console.log(chalk.green(`✓ Sent SIGTERM to task ${taskId} (PID: ${task.pid})`));
+    updateTask(taskId, { status: 'killed', error: 'Killed by user' });
+  } else {
+    console.log(chalk.red(`Failed to kill task ${taskId}`));
+  }
+}

package/task-lib/commands/list.js

@@ -0,0 +1,105 @@
+import chalk from 'chalk';
+import { loadTasks } from '../store.js';
+import { isProcessRunning } from '../runner.js';
+
+export function listTasks(options = {}) {
+  const tasks = loadTasks();
+  const taskList = Object.values(tasks);
+
+  if (taskList.length === 0) {
+    console.log(chalk.dim('No tasks found.'));
+    return;
+  }
+
+  // Sort by creation date, oldest first (chronological)
+  taskList.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
+
+  // Filter by status if specified
+  let filtered = taskList;
+  if (options.status) {
+    filtered = taskList.filter((t) => t.status === options.status);
+  }
+
+  // Limit results
+  const limit = options.limit || 20;
+  filtered = filtered.slice(0, limit);
+
+  // Table format (default) or verbose format
+  if (options.verbose) {
+    // Verbose format (old behavior)
+    console.log(chalk.bold(`\nTasks (${filtered.length}/${taskList.length})\n`));
+
+    for (const task of filtered) {
+      // Verify running status
+      let status = task.status;
+      if (status === 'running' && !isProcessRunning(task.pid)) {
+        status = 'stale';
+      }
+
+      const statusColor =
+        {
+          running: chalk.green,
+          completed: chalk.green,
+          failed: chalk.red,
+          stale: chalk.yellow,
+        }[status] || chalk.dim;
+
+      const age = getAge(task.createdAt);
+      const timestamp = new Date(task.createdAt).toLocaleString();
+
+      console.log(
+        `${statusColor('●')} ${chalk.cyan(task.id)} ${statusColor(`[${status}]`)} ${chalk.dim(age + ' • ' + timestamp)}`
+      );
+      console.log(`  ${chalk.dim('CWD:')} ${task.cwd}`);
+      console.log(`  ${chalk.dim('Prompt:')} ${task.prompt}`);
+      if (task.pid && status === 'running') {
+        console.log(`  ${chalk.dim('PID:')} ${task.pid}`);
+      }
+      if (task.error) {
+        console.log(`  ${chalk.red('Error:')} ${task.error}`);
+      }
+      console.log();
+    }
+  } else {
+    // Table format (clean, default)
+    console.log(chalk.bold(`\n=== Tasks (${filtered.length}/${taskList.length}) ===`));
+    console.log(`${'ID'.padEnd(25)} ${'Status'.padEnd(12)} ${'Age'.padEnd(10)} CWD`);
+    console.log('-'.repeat(100));
+
+    for (const task of filtered) {
+      // Verify running status
+      let status = task.status;
+      if (status === 'running' && !isProcessRunning(task.pid)) {
+        status = 'stale';
+      }
+
+      const statusColor =
+        {
+          running: chalk.green,
+          completed: chalk.green,
+          failed: chalk.red,
+          stale: chalk.yellow,
+        }[status] || chalk.dim;
+
+      const age = getAge(task.createdAt);
+      const cwd = task.cwd.replace(process.env.HOME, '~');
+
+      console.log(
+        `${chalk.cyan(task.id.padEnd(25))} ${statusColor(status.padEnd(12))} ${chalk.dim(age.padEnd(10))} ${chalk.dim(cwd)}`
+      );
+    }
+    console.log();
+  }
+}
+
+function getAge(dateStr) {
+  const diff = Date.now() - new Date(dateStr).getTime();
+  const mins = Math.floor(diff / 60000);
+  const hours = Math.floor(mins / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (mins > 0) return `${mins}m ago`;
+  return 'just now';
+}