@the-open-engine/zeroshot 6.9.1 → 6.10.1

package/task-lib/watcher.js

@@ -5,16 +5,19 @@
  * Runs detached from parent, updates task status on completion
  */
 
-import { spawn } from 'child_process';
-import { appendFileSync, unlinkSync } from 'fs';
-import { unlink } from 'fs/promises';
-import { updateTask } from './store.js';
+import { appendFileSync } from 'fs';
+import { getTask, updateTask } from './store.js';
+import { createCommandSpecCleanup } from './command-spec-cleanup.js';
+import { createProviderSessionCapture } from './provider-session-capture.js';
 import {
-  detectProviderFatalError,
-  detectProviderStreamingModeError,
-  recoverProviderStructuredOutput,
-  supportsProviderStructuredOutputRecovery,
-} from './provider-helper-runtime.js';
+  completeWatcherFailure,
+  completePendingWatcherCancellation,
+  completeWatcherTask,
+  createWatcherOutputRuntime,
+  resolveWatcherCommand,
+  spawnWatcherProvider,
+  terminateWatcherProvider,
+} from './watcher-output-runtime.js';
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
@@ -34,65 +37,42 @@ 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)];
+function emergencyLog(msg) {
+  try {
+    log(msg);
+  } catch {
+    process.stderr.write(msg);
+  }
+}
 
-const child = spawn(command, finalArgs, {
-  cwd: commandSpec.cwd || cwd,
-  env,
-  stdio: ['ignore', 'pipe', 'pipe'],
-  detached: process.platform !== 'win32',
-  windowsHide: true,
+const commandCleanup = createCommandSpecCleanup(commandSpec, (cleanupPath, error) => {
+  emergencyLog(`[${Date.now()}][CLEANUP] Failed to delete ${cleanupPath}: ${error.message}\n`);
 });
 
-updateTask(taskId, {
-  pid: child.pid,
-  processGroupId: process.platform === 'win32' ? null : child.pid,
-  terminationStrategy: process.platform === 'win32' ? 'process-tree' : 'process-group',
+const { providerName, env, command, finalArgs } = resolveWatcherCommand(
+  config,
+  commandSpec,
+  args,
+  normalizeProviderName
+);
+const storedTask = getTask(taskId);
+const providerSessionCapture = createProviderSessionCapture({
+  providerName,
+  taskId,
+  updateTask,
+  log,
+  requestedSessionId: storedTask?.requestedResumeSessionId || null,
+  initialSessionId: storedTask?.sessionId || null,
+  initialSessionIdConflict: storedTask?.sessionIdConflict === true,
 });
 
-const silentJsonMode =
-  config.outputFormat === 'json' &&
-  config.jsonSchema &&
-  config.silentJsonOutput &&
-  supportsProviderStructuredOutputRecovery(providerName);
-
-let finalResultJson = null;
-let streamingModeError = null;
-let fatalError = null;
-let cleanupStarted = false;
-
+let crashStarted = false;
+let child = null;
 let stdoutBuffer = '';
 let stderrBuffer = '';
 
-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`);
-
+function stopProviderAfterFatalOutput() {
+  if (!child) return;
   try {
     child.kill('SIGTERM');
   } catch {
@@ -108,211 +88,120 @@ function maybeHandleFatalError(line, timestamp) {
       }
     }
   }, 5000);
-
-  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 flushStdoutBuffer(timestamp) {
-  if (!stdoutBuffer.trim()) {
-    return;
-  }
-
-  if (!enableRecovery) {
-    if (!silentJsonMode) {
-      log(`[${timestamp}]${stdoutBuffer}\n`);
-    }
-    return;
-  }
-
-  maybeHandleFatalError(stdoutBuffer, timestamp);
-  if (captureStreamingError(stdoutBuffer, timestamp)) {
-    return;
-  }
-
-  if (silentJsonMode) {
-    maybeCaptureStructuredOutput(stdoutBuffer);
-    return;
-  }
+const outputRuntime = createWatcherOutputRuntime({
+  config,
+  providerName,
+  log,
+  stopProvider: stopProviderAfterFatalOutput,
+  providerSessionCapture,
+});
 
-  log(`[${timestamp}]${stdoutBuffer}\n`);
+function terminateOwnedProviderBoundary(exitObserved = false) {
+  return terminateWatcherProvider(child, { exitObserved });
 }
 
-function flushStderrBuffer(timestamp) {
-  if (stderrBuffer.trim()) {
-    maybeHandleFatalError(stderrBuffer, timestamp);
-    log(`[${timestamp}]${stderrBuffer}\n`);
-  }
+async function crashWithError(error, source) {
+  if (crashStarted) return;
+  crashStarted = true;
+  await completeWatcherFailure({
+    taskId,
+    error,
+    source,
+    commandCleanup,
+    terminateProvider: terminateOwnedProviderBoundary,
+    updateTask,
+    emergencyLog,
+  });
+  process.exit(1);
 }
 
-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;
-}
+process.on('uncaughtException', (error) => {
+  void crashWithError(error, 'uncaughtException');
+});
 
-async function cleanupCommandSpec() {
-  if (cleanupStarted) return;
-  cleanupStarted = true;
-  for (const file of commandSpec.cleanup || []) {
-    try {
-      await unlink(file);
-    } catch (error) {
-      log(`[${Date.now()}][CLEANUP] Failed to delete ${file}: ${error.message}\n`);
-    }
-  }
-}
+process.on('unhandledRejection', (reason) => {
+  void crashWithError(reason, 'unhandledRejection');
+});
 
-function cleanupCommandSpecSync() {
-  if (cleanupStarted) return;
-  cleanupStarted = true;
-  for (const file of commandSpec.cleanup || []) {
-    try {
-      unlinkSync(file);
-    } catch (error) {
-      log(`[${Date.now()}][CLEANUP] Failed to delete ${file}: ${error.message}\n`);
-    }
-  }
+if (
+  await completePendingWatcherCancellation({
+    taskId,
+    getTask,
+    commandCleanup,
+    terminateProvider: () => true,
+    updateTask,
+    emergencyLog,
+  })
+) {
+  process.exit(0);
 }
 
-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`);
-}
+child = spawnWatcherProvider(command, finalArgs, {
+  cwd: commandSpec.cwd || cwd,
+  env,
+  stdio: ['ignore', 'pipe', 'pipe'],
+  detached: process.platform !== 'win32',
+});
 
 child.stdout.on('data', (data) => {
-  const chunk = data.toString();
-  const timestamp = Date.now();
-
-  const { lines, remaining } = splitBufferLines(stdoutBuffer, chunk);
-  stdoutBuffer = remaining;
-
-  if (silentJsonMode) {
-    handleSilentJsonLines(lines, timestamp);
-  } else {
-    handleStreamingLines(lines, timestamp);
-  }
+  stdoutBuffer = outputRuntime.consumeOutput(stdoutBuffer, data);
 });
 
 child.stderr.on('data', (data) => {
-  const chunk = data.toString();
-  const timestamp = Date.now();
-
-  const { lines, remaining } = splitBufferLines(stderrBuffer, chunk);
-  stderrBuffer = remaining;
-
-  for (const line of lines) {
-    log(`[${timestamp}]${line}\n`);
-  }
+  stderrBuffer = outputRuntime.consumeStderr(stderrBuffer, data);
 });
 
 child.on('close', async (code, signal) => {
-  const timestamp = Date.now();
-
-  flushStdoutBuffer(timestamp);
-  flushStderrBuffer(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,
-      pid: null,
-      processGroupId: null,
-      exitCode: resolvedCode,
-      error: fatalError || (resolvedCode !== 0 && signal ? `Killed by ${signal}` : null),
-    });
-  } catch (updateError) {
-    log(`[${Date.now()}][ERROR] Failed to update task status: ${updateError.message}\n`);
-  }
+  if (crashStarted) return;
+  const completion = outputRuntime.complete({
+    code,
+    signal,
+    outputBuffer: stdoutBuffer,
+    stderrBuffer,
+  });
+  await completeWatcherTask({
+    taskId,
+    completion,
+    commandCleanup,
+    terminateProvider: () => terminateOwnedProviderBoundary(true),
+    updateTask,
+    emergencyLog,
+  });
   process.exit(0);
 });
 
 child.on('error', async (err) => {
+  if (crashStarted) return;
+  crashStarted = true;
   log(`\nError: ${err.message}\n`);
-  cleanupCommandSpecSync();
-  try {
-    await updateTask(taskId, {
-      status: 'failed',
-      pid: null,
-      processGroupId: null,
-      error: err.message,
-    });
-  } catch (updateError) {
-    log(`[${Date.now()}][ERROR] Failed to update task status: ${updateError.message}\n`);
-  }
+  await completeWatcherTask({
+    taskId,
+    completion: { status: 'failed', resolvedCode: 1, error: err.message },
+    commandCleanup,
+    terminateProvider: terminateOwnedProviderBoundary,
+    updateTask,
+    emergencyLog,
+  });
   process.exit(1);
 });
+
+updateTask(taskId, {
+  pid: child.pid,
+  processGroupId: process.platform === 'win32' ? null : child.pid,
+  terminationStrategy: process.platform === 'win32' ? 'process-tree' : 'process-group',
+});
+
+if (getTask(taskId)?.cancelRequested) {
+  crashStarted = true;
+  await completePendingWatcherCancellation({
+    taskId,
+    getTask,
+    commandCleanup,
+    terminateProvider: terminateOwnedProviderBoundary,
+    updateTask,
+    emergencyLog,
+  });
+  process.exit(0);
+}