@covibes/zeroshot 5.2.1 → 5.4.0

package/src/tui/renderer.js

@@ -37,11 +37,9 @@ class Renderer {
    * @param {Array} clusters - Array of cluster objects
    */
   renderClustersTable(clusters) {
-    if (!clusters || !Array.isArray(clusters)) {
-      clusters = [];
-    }
+    const clusterList = !clusters || !Array.isArray(clusters) ? [] : clusters;
 
-    const data = clusters.map((c) => {
+    const data = clusterList.map((c) => {
       if (!c) return ['', '', '', ''];
 
       const icon = stateIcon(c.state || 'unknown');
@@ -68,23 +66,19 @@ class Renderer {
    * @param {Map} resourceStats - Map of PID -> {cpu, memory}
    */
   renderSystemStats(clusters, resourceStats) {
-    if (!clusters || !Array.isArray(clusters)) {
-      clusters = [];
-    }
-    if (!resourceStats || !(resourceStats instanceof Map)) {
-      resourceStats = new Map();
-    }
+    const clusterList = !clusters || !Array.isArray(clusters) ? [] : clusters;
+    const statsMap = !resourceStats || !(resourceStats instanceof Map) ? new Map() : resourceStats;
 
     // Calculate aggregate stats
-    const activeClusters = clusters.filter((c) => c && c.state === 'running').length;
-    const totalAgents = clusters.reduce((sum, c) => sum + (c?.agentCount || 0), 0);
+    const activeClusters = clusterList.filter((c) => c && c.state === 'running').length;
+    const totalAgents = clusterList.reduce((sum, c) => sum + (c?.agentCount || 0), 0);
 
     // Calculate average CPU and memory from resource stats
     let totalCpu = 0;
     let totalMemory = 0;
     let statCount = 0;
 
-    resourceStats.forEach((stat) => {
+    statsMap.forEach((stat) => {
       if (stat && typeof stat.cpu === 'number' && typeof stat.memory === 'number') {
         totalCpu += stat.cpu;
         totalMemory += stat.memory;
@@ -125,18 +119,14 @@ class Renderer {
       return;
     }
 
-    if (!agents || !Array.isArray(agents)) {
-      agents = [];
-    }
-    if (!resourceStats || !(resourceStats instanceof Map)) {
-      resourceStats = new Map();
-    }
+    const agentList = !agents || !Array.isArray(agents) ? [] : agents;
+    const statsMap = !resourceStats || !(resourceStats instanceof Map) ? new Map() : resourceStats;
 
-    const data = agents.map((a) => {
+    const data = agentList.map((a) => {
       if (!a) return ['', '', '', '', '', ''];
 
       const pid = a.pid;
-      const stats = resourceStats.get(pid) || { cpu: 0, memory: 0 };
+      const stats = statsMap.get(pid) || { cpu: 0, memory: 0 };
 
       const agentId = truncate(a.id || '', 12);
       const role = truncate(a.role || '', 12);

package/task-lib/attachable-watcher.js

@@ -1,42 +1,29 @@
 #!/usr/bin/env node
 
 /**
- * Attachable Watcher - spawns Claude with PTY for attach/detach support
- *
+ * Attachable Watcher - spawns a CLI process with PTY for attach/detach support
  * Runs detached from parent, provides Unix socket for attach clients.
- * Uses node-pty for proper terminal emulation.
- *
- * Key differences from legacy watcher.js:
- * - Uses AttachServer (node-pty) instead of child_process.spawn
- * - Creates Unix socket at ~/.zeroshot/sockets/task-<id>.sock
- * - Supports multiple attached clients
- * - Still writes to log file for backward compatibility
- *
- * CRITICAL: Global error handlers installed FIRST to catch silent crashes
  */
 
 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)
 // ═══════════════════════════════════════════════════════════════════════════
 
-// Parse args early so we can log errors to the correct file
 const [, , taskIdArg, cwdArg, logFileArg, argsJsonArg, configJsonArg] = process.argv;
 
-/**
- * Emergency logger - works even if main log function isn't ready
- */
 function emergencyLog(msg) {
   if (logFileArg) {
     try {
       appendFileSync(logFileArg, msg);
     } catch {
-      // Last resort - stderr
       process.stderr.write(msg);
     }
   } else {
@@ -44,9 +31,6 @@ function emergencyLog(msg) {
   }
 }
 
-/**
- * Mark task as failed and exit
- */
 function crashWithError(error, source) {
   const timestamp = Date.now();
   const errorMsg = error instanceof Error ? error.stack || error.message : String(error);
@@ -54,7 +38,6 @@ function crashWithError(error, source) {
   emergencyLog(`\n[${timestamp}][CRASH] ${source}: ${errorMsg}\n`);
   emergencyLog(`[${timestamp}][CRASH] Process terminating due to unhandled error\n`);
 
-  // Try to update task status - may fail if error is in store.js itself
   if (taskIdArg) {
     try {
       updateTask(taskIdArg, {
@@ -67,11 +50,9 @@ function crashWithError(error, source) {
     }
   }
 
-  // Exit with error code
   process.exit(1);
 }
 
-// Install handlers IMMEDIATELY
 process.on('uncaughtException', (error) => {
   crashWithError(error, 'uncaughtException');
 });
@@ -80,24 +61,19 @@ process.on('unhandledRejection', (reason) => {
   crashWithError(reason, 'unhandledRejection');
 });
 
-// Import attach infrastructure from src package (CommonJS)
-import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const { AttachServer } = require('../src/attach');
-const { getClaudeCommand } = require('../lib/settings.js');
+const { normalizeProviderName } = require('../lib/provider-names');
 
-// Use the args parsed earlier (during error handler setup)
 const taskId = taskIdArg;
 const cwd = cwdArg;
 const logFile = logFileArg;
 const args = JSON.parse(argsJsonArg);
 const config = configJsonArg ? JSON.parse(configJsonArg) : {};
 
-// Socket path for attach
 const SOCKET_DIR = join(homedir(), '.zeroshot', 'sockets');
 const socketPath = join(SOCKET_DIR, `${taskId}.sock`);
 
-// Ensure socket directory exists
 if (!existsSync(SOCKET_DIR)) {
   mkdirSync(SOCKET_DIR, { recursive: true });
 }
@@ -106,33 +82,133 @@ function log(msg) {
   appendFileSync(logFile, msg);
 }
 
-// Build environment - inherit user's auth method (API key or subscription)
-const env = { ...process.env };
-
-// Add model flag - priority: config.model > ANTHROPIC_MODEL env var
-const claudeArgs = [...args];
-const model = config.model || env.ANTHROPIC_MODEL;
-if (model && !claudeArgs.includes('--model')) {
-  claudeArgs.unshift('--model', model);
-}
+const providerName = normalizeProviderName(config.provider || 'claude');
+const enableRecovery = providerName === 'claude';
 
-// Get configured Claude command (supports custom commands like 'ccr code')
-const { command: claudeCommand, args: claudeExtraArgs } = getClaudeCommand();
-const finalArgs = [...claudeExtraArgs, ...claudeArgs];
+const env = { ...process.env, ...(config.env || {}) };
+const command = config.command || 'claude';
+const finalArgs = [...args];
 
-// For JSON schema output with silent mode, track final result
 const silentJsonMode =
-  config.outputFormat === 'json' && config.jsonSchema && config.silentJsonOutput;
-let finalResultJson = null;
+  config.outputFormat === 'json' && config.jsonSchema && config.silentJsonOutput && enableRecovery;
 
-// Buffer for incomplete lines
+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`);
+}
 
-// Create AttachServer to spawn Claude with PTY
 const server = new AttachServer({
   id: taskId,
   socketPath,
-  command: claudeCommand,
+  command,
   args: finalArgs,
   cwd,
   env,
@@ -140,96 +216,62 @@ const server = new AttachServer({
   rows: 30,
 });
 
-// Handle output from PTY
 server.on('output', (data) => {
   const chunk = data.toString();
   const timestamp = Date.now();
 
+  const { lines, remaining } = splitBufferLines(outputBuffer, chunk);
+  outputBuffer = remaining;
+
   if (silentJsonMode) {
-    // Parse each line to find structured_output
-    outputBuffer += chunk;
-    const lines = outputBuffer.split('\n');
-    outputBuffer = lines.pop() || '';
-
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      try {
-        const json = JSON.parse(line);
-        if (json.structured_output) {
-          finalResultJson = line;
-        }
-      } catch {
-        // Not JSON, skip
-      }
-    }
+    handleSilentJsonLines(lines, timestamp);
   } else {
-    // Normal mode - stream with timestamps
-    outputBuffer += chunk;
-    const lines = outputBuffer.split('\n');
-    outputBuffer = lines.pop() || '';
-
-    for (const line of lines) {
-      log(`[${timestamp}]${line}\n`);
-    }
+    handleStreamingLines(lines, timestamp);
   }
 });
 
-// Handle process exit
-server.on('exit', ({ exitCode, signal }) => {
+server.on('exit', async ({ exitCode, signal }) => {
   const timestamp = Date.now();
   const code = exitCode;
 
-  // Flush remaining buffered output
-  if (outputBuffer.trim()) {
-    if (silentJsonMode) {
-      try {
-        const json = JSON.parse(outputBuffer);
-        if (json.structured_output) {
-          finalResultJson = outputBuffer;
-        }
-      } catch {
-        // Not valid JSON
-      }
-    } else {
-      log(`[${timestamp}]${outputBuffer}\n`);
-    }
-  }
+  flushOutputBuffer(timestamp);
+
+  const recovered = attemptRecovery(code, timestamp);
 
-  // In silent JSON mode, log ONLY the final structured_output JSON
   if (silentJsonMode && finalResultJson) {
     log(finalResultJson + '\n');
   }
 
-  // Skip footer for pure JSON output
-  if (config.outputFormat !== 'json') {
-    log(`\n${'='.repeat(50)}\n`);
-    log(`Finished: ${new Date().toISOString()}\n`);
-    log(`Exit code: ${code}, Signal: ${signal}\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`);
   }
 
-  // Simple status: completed if exit 0, failed otherwise
-  const status = code === 0 ? 'completed' : 'failed';
-  updateTask(taskId, {
-    status,
-    exitCode: code,
-    error: signal ? `Killed by ${signal}` : null,
-    socketPath: null, // Clear socket path on exit
-  });
-
-  // Give clients time to receive exit message before exiting
   setTimeout(() => {
     process.exit(0);
   }, 500);
 });
 
-// Handle errors
-server.on('error', (err) => {
+server.on('error', async (err) => {
   log(`\nError: ${err.message}\n`);
-  updateTask(taskId, { status: 'failed', error: err.message });
+  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);
 });
 
-// Handle client attach/detach for logging
 server.on('clientAttach', ({ clientId }) => {
   log(`[${Date.now()}][ATTACH] Client attached: ${clientId.slice(0, 8)}...\n`);
 });
@@ -238,11 +280,9 @@ server.on('clientDetach', ({ clientId }) => {
   log(`[${Date.now()}][DETACH] Client detached: ${clientId.slice(0, 8)}...\n`);
 });
 
-// Start the server
 try {
   await server.start();
 
-  // Update task with PID and socket path
   updateTask(taskId, {
     pid: server.pid,
     socketPath,
@@ -258,7 +298,6 @@ try {
   process.exit(1);
 }
 
-// Handle process signals for cleanup
 process.on('SIGTERM', async () => {
   log(`[${Date.now()}][SYSTEM] Received SIGTERM, stopping...\n`);
   await server.stop('SIGTERM');

package/task-lib/claude-recovery.js

@@ -0,0 +1,156 @@
+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;
+}