@covibes/zeroshot 5.2.1 → 5.3.0

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,24 @@ 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;
 
-// Create AttachServer to spawn Claude with PTY
 const server = new AttachServer({
   id: taskId,
   socketPath,
-  command: claudeCommand,
+  command,
   args: finalArgs,
   cwd,
   env,
@@ -140,19 +107,24 @@ const server = new AttachServer({
   rows: 30,
 });
 
-// Handle output from PTY
 server.on('output', (data) => {
   const chunk = data.toString();
   const timestamp = Date.now();
 
   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;
+      if (enableRecovery) {
+        const detectedError = detectStreamingModeError(line);
+        if (detectedError) {
+          streamingModeError = { ...detectedError, timestamp };
+          continue;
+        }
+      }
       try {
         const json = JSON.parse(line);
         if (json.structured_output) {
@@ -163,73 +135,106 @@ server.on('output', (data) => {
       }
     }
   } else {
-    // Normal mode - stream with timestamps
     outputBuffer += chunk;
     const lines = outputBuffer.split('\n');
     outputBuffer = lines.pop() || '';
 
     for (const line of lines) {
+      if (enableRecovery) {
+        const detectedError = detectStreamingModeError(line);
+        if (detectedError) {
+          streamingModeError = { ...detectedError, timestamp };
+          continue;
+        }
+      }
       log(`[${timestamp}]${line}\n`);
     }
   }
 });
 
-// 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;
+    if (enableRecovery) {
+      const detectedError = detectStreamingModeError(outputBuffer);
+      if (detectedError) {
+        streamingModeError = { ...detectedError, timestamp };
+      } else if (silentJsonMode) {
+        try {
+          const json = JSON.parse(outputBuffer);
+          if (json.structured_output) {
+            finalResultJson = outputBuffer;
+          }
+        } catch {
+          // Not valid JSON
         }
-      } catch {
-        // Not valid JSON
+      } else {
+        log(`[${timestamp}]${outputBuffer}\n`);
       }
-    } else {
+    } else if (!silentJsonMode) {
       log(`[${timestamp}]${outputBuffer}\n`);
     }
   }
 
-  // In silent JSON mode, log ONLY the final structured_output JSON
+  let recovered = null;
+  if (enableRecovery && code !== 0 && streamingModeError?.sessionId) {
+    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`);
+      }
+    }
+  }
+
   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`);
   }
 
-  // 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
-  });
+  const resolvedCode = recovered?.payload ? 0 : code;
+  const status = resolvedCode === 0 ? 'completed' : 'failed';
+  try {
+    await updateTask(taskId, {
+      status,
+      exitCode: resolvedCode,
+      error: resolvedCode === 0 ? null : signal ? `Killed by ${signal}` : null,
+      socketPath: null,
+    });
+  } catch (updateError) {
+    log(`[${Date.now()}][ERROR] Failed to update task status: ${updateError.message}\n`);
+  }
 
-  // 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 +243,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 +261,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,119 @@
+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;
+
+  let fileContents;
+  try {
+    fileContents = readFileSync(jsonlPath, 'utf8');
+  } catch {
+    return null;
+  }
+
+  const lines = fileContents.split('\n');
+  let structuredOutput = null;
+  let usage = null;
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+      const message = entry?.message;
+      const content = message?.content;
+      if (!Array.isArray(content)) continue;
+
+      for (const block of content) {
+        if (block?.type === 'tool_use' && block?.name === 'StructuredOutput' && block?.input) {
+          structuredOutput = block.input;
+          if (message?.usage && typeof message.usage === 'object') {
+            usage = message.usage;
+          }
+        }
+      }
+    } catch {
+      // Skip invalid JSON lines
+    }
+  }
+
+  if (!structuredOutput) return null;
+
+  const payload = {
+    type: 'result',
+    subtype: 'success',
+    is_error: false,
+    structured_output: structuredOutput,
+    session_id: sessionId,
+  };
+
+  if (usage) {
+    payload.usage = usage;
+  }
+
+  return {
+    payload,
+    sourcePath: jsonlPath,
+  };
+}

package/task-lib/commands/list.js

@@ -27,7 +27,7 @@ export function listTasks(options = {}) {
   // Table format (default) or verbose format
   if (options.verbose) {
     // Verbose format (old behavior)
-    console.log(chalk.bold(`\nClaude Tasks (${filtered.length}/${taskList.length})\n`));
+    console.log(chalk.bold(`\nTasks (${filtered.length}/${taskList.length})\n`));
 
     for (const task of filtered) {
       // Verify running status

package/task-lib/commands/resume.js

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import { getTask } from '../store.js';
 import { spawnTask } from '../runner.js';
 
-export function resumeTask(taskId, newPrompt) {
+export async function resumeTask(taskId, newPrompt) {
   const task = getTask(taskId);
 
   if (!task) {
@@ -23,10 +23,11 @@ export function resumeTask(taskId, newPrompt) {
   console.log(chalk.dim(`Original prompt: ${task.prompt}`));
   console.log(chalk.dim(`Resume prompt: ${prompt}`));
 
-  const newTask = spawnTask(prompt, {
+  const newTask = await spawnTask(prompt, {
     cwd: task.cwd,
     continue: true, // Use --continue to load most recent session in that directory
     sessionId: task.sessionId,
+    provider: task.provider,
   });
 
   console.log(chalk.green(`\n✓ Resumed as new task: ${chalk.cyan(newTask.id)}`));

package/task-lib/commands/run.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import { spawnTask } from '../runner.js';
 
-export function runTask(prompt, options = {}) {
+export async function runTask(prompt, options = {}) {
   if (!prompt || prompt.trim().length === 0) {
     console.log(chalk.red('Error: Prompt is required'));
     process.exit(1);
@@ -11,10 +11,16 @@ export function runTask(prompt, options = {}) {
   const jsonSchema = options.jsonSchema;
   const silentJsonOutput = options.silentJsonOutput || false;
 
-  console.log(chalk.dim('Spawning Claude task...'));
+  console.log(chalk.dim('Spawning task...'));
+  if (options.provider) {
+    console.log(chalk.dim(`  Provider: ${options.provider}`));
+  }
   if (options.model) {
     console.log(chalk.dim(`  Model: ${options.model}`));
   }
+  if (options.modelLevel) {
+    console.log(chalk.dim(`  Level: ${options.modelLevel}`));
+  }
   if (jsonSchema && outputFormat === 'json') {
     console.log(chalk.dim(`  JSON Schema: enforced`));
     if (silentJsonOutput) {
@@ -22,9 +28,12 @@ export function runTask(prompt, options = {}) {
     }
   }
 
-  const task = spawnTask(prompt, {
+  const task = await spawnTask(prompt, {
     cwd: options.cwd || process.cwd(),
     model: options.model,
+    modelLevel: options.modelLevel,
+    reasoningEffort: options.reasoningEffort,
+    provider: options.provider,
     resume: options.resume,
     continue: options.continue,
     outputFormat,

package/task-lib/runner.js

@@ -1,55 +1,76 @@
 import { fork } from 'child_process';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { LOGS_DIR, DEFAULT_MODEL } from './config.js';
+import { LOGS_DIR } from './config.js';
 import { addTask, generateId, ensureDirs } from './store.js';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const { loadSettings } = require('../lib/settings.js');
+const { normalizeProviderName } = require('../lib/provider-names');
+const { getProvider } = require('../src/providers');
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-export function spawnTask(prompt, options = {}) {
+export async function spawnTask(prompt, options = {}) {
   ensureDirs();
 
   const id = generateId();
   const logFile = join(LOGS_DIR, `${id}.log`);
   const cwd = options.cwd || process.cwd();
-  const model = options.model || process.env.ANTHROPIC_MODEL || DEFAULT_MODEL;
 
-  // Build claude command args
-  // --print: non-interactive mode
-  // --dangerously-skip-permissions: background tasks can't prompt for approval (CRITICAL)
-  // --output-format: stream-json (default) for real-time, text for clean output, json for structured
+  const settings = loadSettings();
+  const providerName = normalizeProviderName(
+    options.provider || settings.defaultProvider || 'claude'
+  );
+  const provider = getProvider(providerName);
+  const providerSettings = settings.providerSettings?.[providerName] || {};
+  const levelOverrides = providerSettings.levelOverrides || {};
+
   const outputFormat = options.outputFormat || 'stream-json';
-  const args = ['--print', '--dangerously-skip-permissions', '--output-format', outputFormat];
 
-  // Only add streaming options for stream-json format
-  if (outputFormat === 'stream-json') {
-    args.push('--verbose');
-    // Include partial messages to get streaming updates before completion (required for stream-json format)
-    args.push('--include-partial-messages');
+  let jsonSchema = options.jsonSchema || null;
+  if (jsonSchema && outputFormat !== 'json') {
+    console.warn('Warning: --json-schema requires --output-format json, ignoring schema');
+    jsonSchema = null;
   }
 
-  // Add JSON schema if provided (only works with --output-format json)
-  if (options.jsonSchema) {
-    if (outputFormat !== 'json') {
-      console.warn('Warning: --json-schema requires --output-format json, ignoring schema');
-    } else {
-      // CRITICAL: Must stringify schema object before passing to CLI (like zeroshot does)
-      const schemaString =
-        typeof options.jsonSchema === 'string'
-          ? options.jsonSchema
-          : JSON.stringify(options.jsonSchema);
-      args.push('--json-schema', schemaString);
+  let modelSpec;
+  if (options.model) {
+    modelSpec = {
+      model: options.model,
+      reasoningEffort: options.reasoningEffort,
+    };
+  } else {
+    const level = options.modelLevel || providerSettings.defaultLevel || provider.getDefaultLevel();
+    modelSpec = provider.resolveModelSpec(level, levelOverrides);
+    if (options.reasoningEffort) {
+      modelSpec = { ...modelSpec, reasoningEffort: options.reasoningEffort };
     }
   }
 
-  if (options.resume) {
-    args.push('--resume', options.resume);
-  } else if (options.continue) {
-    args.push('--continue');
+  const cliFeatures = await provider.getCliFeatures();
+  const commandSpec = provider.buildCommand(prompt, {
+    modelSpec,
+    outputFormat,
+    jsonSchema,
+    cwd,
+    autoApprove: true,
+    cliFeatures,
+  });
+
+  const finalArgs = [...commandSpec.args];
+  if (providerName === 'claude') {
+    const promptIndex = finalArgs.length - 1;
+    if (options.resume) {
+      finalArgs.splice(promptIndex, 0, '--resume', options.resume);
+    } else if (options.continue) {
+      finalArgs.splice(promptIndex, 0, '--continue');
+    }
+  } else if (options.resume || options.continue) {
+    console.warn('Warning: resume/continue is only supported for Claude CLI; ignoring.');
   }
 
-  args.push(prompt);
-
   const task = {
     id,
     prompt: prompt.slice(0, 200) + (prompt.length > 200 ? '...' : ''),
@@ -63,6 +84,8 @@ export function spawnTask(prompt, options = {}) {
     updatedAt: new Date().toISOString(),
     exitCode: null,
     error: null,
+    provider: providerName,
+    model: modelSpec?.model || null,
     // Schedule reference (if spawned by scheduler)
     scheduleId: options.scheduleId || null,
     // Attach support
@@ -72,24 +95,23 @@ export function spawnTask(prompt, options = {}) {
 
   addTask(task);
 
-  // Fork a watcher process that will manage the claude process
   const watcherConfig = {
     outputFormat,
-    jsonSchema: options.jsonSchema || null,
+    jsonSchema,
     silentJsonOutput: options.silentJsonOutput || false,
-    model,
+    provider: providerName,
+    command: commandSpec.binary,
+    env: commandSpec.env || {},
   };
 
-  // Use attachable watcher by default (unless explicitly disabled)
-  // Attachable watcher uses node-pty and creates a Unix socket for attach/detach
-  const useAttachable = options.attachable !== false;
+  const useAttachable = options.attachable !== false && !options.jsonSchema;
   const watcherScript = useAttachable
     ? join(__dirname, 'attachable-watcher.js')
     : join(__dirname, 'watcher.js');
 
   const watcher = fork(
     watcherScript,
-    [id, cwd, logFile, JSON.stringify(args), JSON.stringify(watcherConfig)],
+    [id, cwd, logFile, JSON.stringify(finalArgs), JSON.stringify(watcherConfig)],
     {
       detached: true,
       stdio: 'ignore',
@@ -98,7 +120,6 @@ export function spawnTask(prompt, options = {}) {
 
   watcher.unref();
 
-  // Return task immediately - watcher will update PID async
   return task;
 }
 

package/task-lib/scheduler.js

@@ -108,7 +108,7 @@ function log(msg) {
 /**
  * Check and run due schedules
  */
-function checkSchedules() {
+async function checkSchedules() {
   const schedules = loadSchedules();
   const now = new Date();
 
@@ -122,7 +122,7 @@ function checkSchedules() {
     log(`Running scheduled task: ${schedule.id} - "${schedule.prompt.slice(0, 50)}..."`);
 
     try {
-      const task = spawnTask(schedule.prompt, {
+      const task = await spawnTask(schedule.prompt, {
         cwd: schedule.cwd,
         scheduleId: schedule.id,
       });