@covibes/zeroshot 5.4.0 → 5.4.1

package/task-lib/attachable-watcher.js

@@ -1,309 +0,0 @@
-#!/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 } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-import { updateTask } from './store.js';
-import { detectStreamingModeError, recoverStructuredOutput } from './claude-recovery.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;
-
-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`);
-
-  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 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 = providerName === 'claude';
-
-const env = { ...process.env, ...(config.env || {}) };
-const command = config.command || 'claude';
-const finalArgs = [...args];
-
-const silentJsonMode =
-  config.outputFormat === 'json' && config.jsonSchema && config.silentJsonOutput && enableRecovery;
-
-let finalResultJson = null;
-let outputBuffer = '';
-let streamingModeError = null;
-
-function splitBufferLines(buffer, chunk) {
-  const nextBuffer = buffer + chunk;
-  const lines = nextBuffer.split('\n');
-  const remaining = lines.pop() || '';
-  return { lines, remaining };
-}
-
-function captureStreamingError(line, timestamp) {
-  if (!enableRecovery) {
-    return false;
-  }
-
-  const detectedError = detectStreamingModeError(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;
-    if (captureStreamingError(line, timestamp)) {
-      continue;
-    }
-    maybeCaptureStructuredOutput(line);
-  }
-}
-
-function handleStreamingLines(lines, timestamp) {
-  for (const line of lines) {
-    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;
-  }
-
-  if (captureStreamingError(outputBuffer, timestamp)) {
-    return;
-  }
-
-  if (silentJsonMode) {
-    maybeCaptureStructuredOutput(outputBuffer);
-    return;
-  }
-
-  log(`[${timestamp}]${outputBuffer}\n`);
-}
-
-function attemptRecovery(code, timestamp) {
-  if (!(enableRecovery && code !== 0 && streamingModeError?.sessionId)) {
-    return null;
-  }
-
-  const recovered = recoverStructuredOutput(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;
-}
-
-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`);
-}
-
-const server = new AttachServer({
-  id: taskId,
-  socketPath,
-  command,
-  args: finalArgs,
-  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);
-
-  const resolvedCode = recovered?.payload ? 0 : code;
-  const status = resolvedCode === 0 ? 'completed' : 'failed';
-  try {
-    await updateTask(taskId, {
-      status,
-      exitCode: resolvedCode,
-      error: 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`);
-  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`);
-  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/claude-recovery.js

@@ -1,156 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-
-export const STREAMING_MODE_ERROR = 'only prompt commands are supported in streaming mode';
-
-export function detectStreamingModeError(line) {
-  const trimmed = typeof line === 'string' ? line.trim() : '';
-  if (!trimmed.startsWith('{')) return null;
-
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (
-      parsed &&
-      parsed.type === 'result' &&
-      parsed.is_error === true &&
-      Array.isArray(parsed.errors) &&
-      parsed.errors.includes(STREAMING_MODE_ERROR) &&
-      typeof parsed.session_id === 'string'
-    ) {
-      return {
-        sessionId: parsed.session_id,
-        line: trimmed,
-      };
-    }
-  } catch {
-    // Ignore parse errors - not JSON
-  }
-
-  return null;
-}
-
-function findSessionJsonlPath(sessionId) {
-  const claudeDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
-  const projectsDir = join(claudeDir, 'projects');
-  if (!existsSync(projectsDir)) return null;
-
-  const target = `${sessionId}.jsonl`;
-  const queue = [projectsDir];
-
-  while (queue.length > 0) {
-    const dir = queue.pop();
-    if (!dir) continue;
-
-    let entries;
-    try {
-      entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name === target) {
-        return join(dir, entry.name);
-      }
-      if (entry.isDirectory()) {
-        queue.push(join(dir, entry.name));
-      }
-    }
-  }
-
-  return null;
-}
-
-export function recoverStructuredOutput(sessionId) {
-  const jsonlPath = findSessionJsonlPath(sessionId);
-  if (!jsonlPath) return null;
-
-  const fileContents = readJsonlFile(jsonlPath);
-  if (!fileContents) return null;
-
-  const { structuredOutput, usage } = findStructuredOutput(fileContents);
-
-  if (!structuredOutput) return null;
-
-  return {
-    payload: buildStructuredOutputPayload(sessionId, structuredOutput, usage),
-    sourcePath: jsonlPath,
-  };
-}
-
-function readJsonlFile(jsonlPath) {
-  try {
-    return readFileSync(jsonlPath, 'utf8');
-  } catch {
-    return null;
-  }
-}
-
-function findStructuredOutput(fileContents) {
-  const lines = fileContents.split('\n');
-  let structuredOutput = null;
-  let usage = null;
-
-  for (const line of lines) {
-    const entry = parseJsonLine(line);
-    if (!entry) {
-      continue;
-    }
-
-    const extracted = extractStructuredOutputFromEntry(entry);
-    if (extracted) {
-      structuredOutput = extracted.structuredOutput;
-      usage = extracted.usage;
-    }
-  }
-
-  return { structuredOutput, usage };
-}
-
-function parseJsonLine(line) {
-  if (!line.trim()) return null;
-  try {
-    return JSON.parse(line);
-  } catch {
-    // Skip invalid JSON lines
-    return null;
-  }
-}
-
-function extractStructuredOutputFromEntry(entry) {
-  const message = entry?.message;
-  const content = message?.content;
-  if (!Array.isArray(content)) return null;
-
-  let structuredOutput = null;
-  let usage = null;
-  for (const block of content) {
-    if (block?.type === 'tool_use' && block?.name === 'StructuredOutput' && block?.input) {
-      structuredOutput = block.input;
-      usage = message?.usage && typeof message.usage === 'object' ? message.usage : null;
-    }
-  }
-
-  if (!structuredOutput) {
-    return null;
-  }
-
-  return { structuredOutput, usage };
-}
-
-function buildStructuredOutputPayload(sessionId, structuredOutput, usage) {
-  const payload = {
-    type: 'result',
-    subtype: 'success',
-    is_error: false,
-    structured_output: structuredOutput,
-    session_id: sessionId,
-  };
-
-  if (usage) {
-    payload.usage = usage;
-  }
-
-  return payload;
-}

package/task-lib/commands/clean.js

@@ -1,50 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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}`));
-  }
-}