@covibes/zeroshot 5.3.0 → 5.4.0

package/src/process-metrics.js

@@ -13,7 +13,7 @@
  * - macOS: ps + lsof
  */
 
-const { execSync } = require('child_process');
+const { execSync } = require('./lib/safe-exec'); // Enforces timeouts
 const fs = require('fs');
 
 const PLATFORM = process.platform;
@@ -56,41 +56,13 @@ function getChildPids(pid) {
   const children = [];
 
   try {
-    if (PLATFORM === 'darwin') {
-      // macOS: Use pgrep with -P flag
-      const output = execSync(`pgrep -P ${escapeShell(String(pid))} 2>/dev/null`, {
-        encoding: 'utf8',
-        timeout: 2000,
-      });
-      const pids = output.trim().split('\n').filter(Boolean).map(Number);
-      children.push(...pids);
-
-      // Recursively get grandchildren
-      for (const childPid of pids) {
-        children.push(...getChildPids(childPid));
-      }
-    } else {
-      // Linux: Read /proc/{pid}/task/{tid}/children
-      const taskPath = `/proc/${pid}/task`;
-      if (fs.existsSync(taskPath)) {
-        const tids = fs.readdirSync(taskPath);
-        for (const tid of tids) {
-          const childrenPath = `/proc/${pid}/task/${tid}/children`;
-          if (fs.existsSync(childrenPath)) {
-            const childPids = fs.readFileSync(childrenPath, 'utf8')
-              .trim()
-              .split(/\s+/)
-              .filter(Boolean)
-              .map(Number);
-            children.push(...childPids);
-
-            // Recursively get grandchildren
-            for (const childPid of childPids) {
-              children.push(...getChildPids(childPid));
-            }
-          }
-        }
-      }
+    const childPids =
+      PLATFORM === 'darwin' ? collectDarwinChildPids(pid) : collectLinuxChildPids(pid);
+    children.push(...childPids);
+
+    // Recursively get grandchildren
+    for (const childPid of childPids) {
+      children.push(...getChildPids(childPid));
     }
   } catch {
     // Ignore errors (process may have exited)
@@ -99,6 +71,45 @@ function getChildPids(pid) {
   return [...new Set(children)]; // Dedupe
 }
 
+function collectDarwinChildPids(pid) {
+  const output = execSync(`pgrep -P ${escapeShell(String(pid))} 2>/dev/null`, {
+    encoding: 'utf8',
+    timeout: 2000,
+  });
+
+  return output.trim().split('\n').filter(Boolean).map(Number);
+}
+
+function collectLinuxChildPids(pid) {
+  const taskPath = `/proc/${pid}/task`;
+  if (!fs.existsSync(taskPath)) {
+    return [];
+  }
+
+  const tids = fs.readdirSync(taskPath);
+  const childPids = [];
+
+  for (const tid of tids) {
+    const childrenPath = `/proc/${pid}/task/${tid}/children`;
+    childPids.push(...readChildPidFile(childrenPath));
+  }
+
+  return childPids;
+}
+
+function readChildPidFile(childrenPath) {
+  if (!fs.existsSync(childrenPath)) {
+    return [];
+  }
+
+  const raw = fs.readFileSync(childrenPath, 'utf8').trim();
+  if (!raw) {
+    return [];
+  }
+
+  return raw.split(/\s+/).filter(Boolean).map(Number);
+}
+
 /**
  * Get metrics for a single process (Linux)
  * @param {number} pid - Process ID
@@ -187,17 +198,20 @@ function getNetworkStateLinux(pid) {
     hasActivity: false,
     sendQueueBytes: 0,
     recvQueueBytes: 0,
-    bytesSent: 0,      // Cumulative bytes sent across all sockets
-    bytesReceived: 0,  // Cumulative bytes received across all sockets
+    bytesSent: 0, // Cumulative bytes sent across all sockets
+    bytesReceived: 0, // Cumulative bytes received across all sockets
   };
 
   try {
     // Use ss -tip to get extended TCP info with bytes_sent/bytes_received
     // -t = TCP only, -i = show internal TCP info, -p = show process
-    const output = execSync(`ss -tip 2>/dev/null | grep -A1 "pid=${escapeShell(String(pid))}," || true`, {
-      encoding: 'utf8',
-      timeout: 3000,
-    });
+    const output = execSync(
+      `ss -tip 2>/dev/null | grep -A1 "pid=${escapeShell(String(pid))}," || true`,
+      {
+        encoding: 'utf8',
+        timeout: 3000,
+      }
+    );
 
     if (!output.trim()) {
       return result;
@@ -261,8 +275,8 @@ function getNetworkStateDarwin(pid) {
     hasActivity: false,
     sendQueueBytes: 0,
     recvQueueBytes: 0,
-    bytesSent: 0,      // Not available on macOS without root/dtrace
-    bytesReceived: 0,  // Not available on macOS without root/dtrace
+    bytesSent: 0, // Not available on macOS without root/dtrace
+    bytesReceived: 0, // Not available on macOS without root/dtrace
   };
 
   try {
@@ -281,7 +295,7 @@ function getNetworkStateDarwin(pid) {
     for (const line of lines) {
       const parts = line.split(/\s+/);
       // Look for ESTABLISHED connections
-      if (parts.includes('ESTABLISHED') || parts.some(p => p.includes('->'))) {
+      if (parts.includes('ESTABLISHED') || parts.some((p) => p.includes('->'))) {
         result.established++;
         result.hasActivity = true; // lsof doesn't show queue sizes, assume activity
       }
@@ -334,14 +348,21 @@ async function getProcessMetricsLinuxAggregated(pid, samplePeriodMs) {
       memoryMB: 0,
       state: 'X',
       threads: 0,
-      network: { established: 0, hasActivity: false, sendQueueBytes: 0, recvQueueBytes: 0, bytesSent: 0, bytesReceived: 0 },
+      network: {
+        established: 0,
+        hasActivity: false,
+        sendQueueBytes: 0,
+        recvQueueBytes: 0,
+        bytesSent: 0,
+        bytesReceived: 0,
+      },
       childCount: 0,
       timestamp: Date.now(),
     };
   }
 
   // Wait for sample period
-  await new Promise(r => setTimeout(r, samplePeriodMs));
+  await new Promise((r) => setTimeout(r, samplePeriodMs));
 
   // Get second CPU sample
   const t1Metrics = {};
@@ -385,7 +406,14 @@ async function getProcessMetricsLinuxAggregated(pid, samplePeriodMs) {
   const cpuPercent = Math.min(100, rawCpuPercent / cpuCores);
 
   // Get network state for all processes
-  let network = { established: 0, hasActivity: false, sendQueueBytes: 0, recvQueueBytes: 0, bytesSent: 0, bytesReceived: 0 };
+  let network = {
+    established: 0,
+    hasActivity: false,
+    sendQueueBytes: 0,
+    recvQueueBytes: 0,
+    bytesSent: 0,
+    bytesReceived: 0,
+  };
   for (const p of Object.keys(t1Metrics)) {
     const netState = getNetworkStateLinux(parseInt(p, 10));
     network.established += netState.established;
@@ -451,7 +479,14 @@ function getProcessMetricsDarwinAggregated(pid) {
   }
 
   // Get network state
-  let network = { established: 0, hasActivity: false, sendQueueBytes: 0, recvQueueBytes: 0, bytesSent: 0, bytesReceived: 0 };
+  let network = {
+    established: 0,
+    hasActivity: false,
+    sendQueueBytes: 0,
+    recvQueueBytes: 0,
+    bytesSent: 0,
+    bytesReceived: 0,
+  };
   for (const p of allPids) {
     const netState = getNetworkStateDarwin(p);
     network.established += netState.established;
@@ -518,13 +553,20 @@ function formatMetrics(metrics) {
  */
 function getStateIcon(state) {
   switch (state) {
-    case 'R': return '🟢'; // Running
-    case 'S': return '🔵'; // Sleeping
-    case 'D': return '🟡'; // Disk wait
-    case 'Z': return '💀'; // Zombie
-    case 'T': return '⏸️'; // Stopped
-    case 'X': return '❌'; // Dead
-    default: return '⚪';
+    case 'R':
+      return '🟢'; // Running
+    case 'S':
+      return '🔵'; // Sleeping
+    case 'D':
+      return '🟡'; // Disk wait
+    case 'Z':
+      return '💀'; // Zombie
+    case 'T':
+      return '⏸️'; // Stopped
+    case 'X':
+      return '❌'; // Dead
+    default:
+      return '⚪';
   }
 }
 

package/src/providers/anthropic/cli-builder.js

@@ -1,43 +1,71 @@
 function buildCommand(context, options = {}, commandConfig = {}) {
-  const { modelSpec, outputFormat, jsonSchema, autoApprove, cliFeatures = {} } = options;
+  const {
+    modelSpec,
+    outputFormat,
+    jsonSchema,
+    autoApprove,
+    cliFeatures = {},
+    authEnv = {},
+  } = options;
 
   const command = commandConfig.command || 'claude';
   const extraArgs = commandConfig.args || [];
   const args = [...extraArgs, '--print', '--input-format', 'text'];
 
-  if (outputFormat && cliFeatures.supportsOutputFormat !== false) {
-    args.push('--output-format', outputFormat);
-  }
+  addOutputFormatArgs(args, outputFormat, cliFeatures);
+  addStreamJsonArgs(args, outputFormat, cliFeatures);
+  addJsonSchemaArgs(args, outputFormat, jsonSchema, cliFeatures);
+  addModelArgs(args, modelSpec, cliFeatures);
+  addAutoApproveArgs(args, autoApprove, cliFeatures);
 
-  if (outputFormat === 'stream-json') {
-    if (cliFeatures.supportsVerbose !== false) {
-      args.push('--verbose');
-    }
-    if (cliFeatures.supportsIncludePartials !== false) {
-      args.push('--include-partial-messages');
-    }
-  }
+  args.push(context);
 
-  if (jsonSchema && outputFormat === 'json' && cliFeatures.supportsJsonSchema !== false) {
-    const schemaString = typeof jsonSchema === 'string' ? jsonSchema : JSON.stringify(jsonSchema);
-    args.push('--json-schema', schemaString);
+  return {
+    binary: command,
+    args,
+    env: authEnv,
+  };
+}
+
+function addOutputFormatArgs(args, outputFormat, cliFeatures) {
+  if (!outputFormat || cliFeatures.supportsOutputFormat === false) {
+    return;
   }
+  args.push('--output-format', outputFormat);
+}
 
-  if (modelSpec?.model && cliFeatures.supportsModel !== false) {
-    args.push('--model', modelSpec.model);
+function addStreamJsonArgs(args, outputFormat, cliFeatures) {
+  if (outputFormat !== 'stream-json') {
+    return;
+  }
+  if (cliFeatures.supportsVerbose !== false) {
+    args.push('--verbose');
   }
+  if (cliFeatures.supportsIncludePartials !== false) {
+    args.push('--include-partial-messages');
+  }
+}
 
-  if (autoApprove && cliFeatures.supportsAutoApprove !== false) {
-    args.push('--dangerously-skip-permissions');
+function addJsonSchemaArgs(args, outputFormat, jsonSchema, cliFeatures) {
+  if (!jsonSchema || outputFormat !== 'json' || cliFeatures.supportsJsonSchema === false) {
+    return;
   }
+  const schemaString = typeof jsonSchema === 'string' ? jsonSchema : JSON.stringify(jsonSchema);
+  args.push('--json-schema', schemaString);
+}
 
-  args.push(context);
+function addModelArgs(args, modelSpec, cliFeatures) {
+  if (!modelSpec?.model || cliFeatures.supportsModel === false) {
+    return;
+  }
+  args.push('--model', modelSpec.model);
+}
 
-  return {
-    binary: command,
-    args,
-    env: {},
-  };
+function addAutoApproveArgs(args, autoApprove, cliFeatures) {
+  if (!autoApprove || cliFeatures.supportsAutoApprove === false) {
+    return;
+  }
+  args.push('--dangerously-skip-permissions');
 }
 
 module.exports = {

package/src/providers/anthropic/index.js

@@ -1,6 +1,7 @@
 const BaseProvider = require('../base-provider');
-const { getClaudeCommand } = require('../../../lib/settings');
+const { getClaudeCommand, loadSettings } = require('../../../lib/settings');
 const { commandExists, getCommandPath, getHelpOutput } = require('../../../lib/provider-detection');
+const { resolveClaudeAuth } = require('../../../lib/settings/claude-auth');
 const { buildCommand } = require('./cli-builder');
 const { parseEvent } = require('./output-parser');
 const {
@@ -68,6 +69,16 @@ class AnthropicProvider extends BaseProvider {
     return ['~/.claude'];
   }
 
+  /**
+   * Resolve authentication environment variables for Claude CLI.
+   * Handles Bedrock, API key, and OAuth authentication.
+   * @returns {Object} Environment variables for authentication
+   */
+  resolveAuthEnv() {
+    const settings = loadSettings();
+    return resolveClaudeAuth(settings);
+  }
+
   buildCommand(context, options) {
     const { command, args } = getClaudeCommand();
     const cliFeatures = options.cliFeatures || {};
@@ -97,7 +108,10 @@ class AnthropicProvider extends BaseProvider {
       );
     }
 
-    return buildCommand(context, { ...options, cliFeatures }, { command, args });
+    const authEnv = this.resolveAuthEnv();
+    const resolvedOptions = { ...options, cliFeatures, authEnv };
+
+    return buildCommand(context, resolvedOptions, { command, args });
   }
 
   parseEvent(line) {
@@ -129,6 +143,62 @@ class AnthropicProvider extends BaseProvider {
     warned.add(key);
     console.warn(`⚠️ ${message}`);
   }
+
+  /**
+   * Get default settings including Claude-specific auth fields
+   * @override
+   */
+  getDefaultSettings() {
+    return {
+      ...super.getDefaultSettings(),
+      // Authentication (optional persistent storage)
+      anthropicApiKey: null, // sk-ant-* key
+      bedrockApiKey: null, // AWS_BEARER_TOKEN_BEDROCK value
+      bedrockRegion: null, // AWS_REGION for Bedrock
+    };
+  }
+
+  /**
+   * Validate Claude-specific settings including auth fields
+   * @override
+   */
+  validateSettings(settings) {
+    // First validate base provider settings (levels, etc.)
+    const baseError = super.validateSettings(settings);
+    if (baseError) return baseError;
+
+    // Claude-specific auth field validation
+    const {
+      isValidAnthropicKey,
+      ANTHROPIC_KEY_PREFIX,
+    } = require('../../../lib/settings/claude-auth');
+
+    // Validate string-or-null fields
+    for (const field of ['anthropicApiKey', 'bedrockApiKey', 'bedrockRegion']) {
+      if (
+        settings[field] !== undefined &&
+        settings[field] !== null &&
+        typeof settings[field] !== 'string'
+      ) {
+        return `providerSettings.claude.${field} must be a string or null`;
+      }
+    }
+
+    // Additional prefix validation for Anthropic API key
+    if (settings.anthropicApiKey && !isValidAnthropicKey(settings.anthropicApiKey)) {
+      return `providerSettings.claude.anthropicApiKey must start with ${ANTHROPIC_KEY_PREFIX}`;
+    }
+
+    return null;
+  }
+
+  /**
+   * Get Claude-specific setting field names
+   * @override
+   */
+  getSettingsFields() {
+    return [...super.getSettingsFields(), 'anthropicApiKey', 'bedrockApiKey', 'bedrockRegion'];
+  }
 }
 
 module.exports = AnthropicProvider;

package/src/providers/anthropic/output-parser.js

@@ -2,6 +2,28 @@
  * Stream JSON Parser for Claude Code output
  */
 
+/**
+ * Parse result event type
+ * @param {Object} event
+ * @returns {Object}
+ */
+function parseResultEvent(event) {
+  const usage = event.usage || {};
+  return {
+    type: 'result',
+    success: event.subtype === 'success',
+    result: event.result,
+    error: event.is_error ? event.result : null,
+    cost: event.total_cost_usd,
+    duration: event.duration_ms,
+    inputTokens: usage.input_tokens || 0,
+    outputTokens: usage.output_tokens || 0,
+    cacheReadInputTokens: usage.cache_read_input_tokens || 0,
+    cacheCreationInputTokens: usage.cache_creation_input_tokens || 0,
+    modelUsage: event.modelUsage || null,
+  };
+}
+
 /**
  * Parse a single JSON line and extract displayable content
  * @param {string} line
@@ -33,20 +55,7 @@ function parseEvent(line) {
   }
 
   if (event.type === 'result') {
-    const usage = event.usage || {};
-    return {
-      type: 'result',
-      success: event.subtype === 'success',
-      result: event.result,
-      error: event.is_error ? event.result : null,
-      cost: event.total_cost_usd,
-      duration: event.duration_ms,
-      inputTokens: usage.input_tokens || 0,
-      outputTokens: usage.output_tokens || 0,
-      cacheReadInputTokens: usage.cache_read_input_tokens || 0,
-      cacheCreationInputTokens: usage.cache_creation_input_tokens || 0,
-      modelUsage: event.modelUsage || null,
-    };
+    return parseResultEvent(event);
   }
 
   if (event.type === 'system') {
@@ -82,6 +91,15 @@ function parseAssistantMessage(message) {
   const results = [];
 
   for (const block of message.content) {
+    // Handle text content blocks (CRITICAL for Haiku/weaker models that return JSON in text)
+    // Issue #52: Haiku returns JSON in type:text blocks, not in result wrapper
+    if (block.type === 'text' && block.text) {
+      results.push({
+        type: 'text',
+        text: block.text,
+      });
+    }
+
     if (block.type === 'tool_use') {
       results.push({
         type: 'tool_call',

package/src/providers/base-provider.js

@@ -173,9 +173,79 @@ class BaseProvider {
     return modelId;
   }
 
+  /**
+   * Resolve a model name to its CLI-compatible identifier.
+   * Override in provider implementations that need model ID transformation
+   * (e.g., Anthropic Bedrock mapping).
+   * @param {string} model - Model name (e.g., 'opus', 'sonnet')
+   * @param {Object} _authEnv - Authentication environment variables
+   * @returns {string} CLI-compatible model identifier
+   */
+  resolveCliModel(model, _authEnv = {}) {
+    return model;
+  }
+
   getDefaultLevel() {
     throw new Error('Not implemented');
   }
+
+  /**
+   * Get default settings for this provider
+   * Override in provider implementations to provide provider-specific defaults
+   * @returns {Object} Default settings object
+   */
+  getDefaultSettings() {
+    return {
+      maxLevel: this.getDefaultMaxLevel?.() || 'level3',
+      minLevel: this.getDefaultMinLevel?.() || 'level1',
+      defaultLevel: this.getDefaultLevel() || 'level2',
+      levelOverrides: {},
+    };
+  }
+
+  /**
+   * Validate provider-specific settings
+   * Override in provider implementations to add custom validation
+   * @param {Object} settings - Settings object to validate
+   * @returns {string|null} Error message if invalid, null if valid
+   */
+  validateSettings(settings) {
+    if (typeof settings !== 'object' || settings === null) {
+      return `providerSettings.${this.name} must be an object`;
+    }
+
+    // Validate level fields
+    const levelMapping = this.getLevelMapping();
+    const validLevels = Object.keys(levelMapping);
+
+    if (settings.maxLevel && !validLevels.includes(settings.maxLevel)) {
+      return `Invalid maxLevel for ${this.name}: ${settings.maxLevel}`;
+    }
+    if (settings.minLevel && !validLevels.includes(settings.minLevel)) {
+      return `Invalid minLevel for ${this.name}: ${settings.minLevel}`;
+    }
+    if (settings.defaultLevel && !validLevels.includes(settings.defaultLevel)) {
+      return `Invalid defaultLevel for ${this.name}: ${settings.defaultLevel}`;
+    }
+
+    if (
+      settings.levelOverrides &&
+      (typeof settings.levelOverrides !== 'object' || Array.isArray(settings.levelOverrides))
+    ) {
+      return `levelOverrides for ${this.name} must be an object`;
+    }
+
+    return null;
+  }
+
+  /**
+   * Get the list of setting field names specific to this provider
+   * Override in provider implementations to declare custom fields
+   * @returns {string[]} Array of field names
+   */
+  getSettingsFields() {
+    return ['maxLevel', 'minLevel', 'defaultLevel', 'levelOverrides'];
+  }
 }
 
 module.exports = BaseProvider;

package/src/providers/capabilities.js

@@ -28,6 +28,15 @@ const CAPABILITIES = {
     thinkingMode: true,
     reasoningEffort: false,
   },
+  opencode: {
+    dockerIsolation: true,
+    worktreeIsolation: true,
+    mcpServers: true,
+    jsonSchema: 'experimental',
+    streamJson: true,
+    thinkingMode: true,
+    reasoningEffort: true,
+  },
 };
 
 function checkCapability(provider, capability) {

package/src/providers/google/output-parser.js

@@ -9,6 +9,47 @@ function normalizeMessageContent(content) {
   return '';
 }
 
+function parseMessageEvent(event) {
+  if (event.role === 'assistant') {
+    const text = normalizeMessageContent(event.content);
+    if (text) {
+      return { type: 'text', text };
+    }
+  }
+  return null;
+}
+
+function parseToolUseEvent(event, state) {
+  const toolId = event.tool_call_id || event.tool_id || event.id || state.lastToolId;
+  const toolName = event.tool_name || event.name;
+  state.lastToolId = toolId;
+  return {
+    type: 'tool_call',
+    toolName,
+    toolId,
+    input: event.parameters || event.input || {},
+  };
+}
+
+function parseToolResultEvent(event, state) {
+  const toolId = event.tool_call_id || event.tool_id || event.id || state.lastToolId;
+  return {
+    type: 'tool_result',
+    toolId,
+    content: event.output ?? event.content ?? '',
+    isError: event.success === false,
+  };
+}
+
+function parseResultEvent(event) {
+  return {
+    type: 'result',
+    success: event.success !== false,
+    result: event.result || '',
+    error: event.success === false ? event.error || 'Result failed' : null,
+  };
+}
+
 function parseEvent(line, state = {}, options = {}) {
   let event;
   try {
@@ -20,46 +61,14 @@ function parseEvent(line, state = {}, options = {}) {
   switch (event.type) {
     case 'init':
       return null;
-
     case 'message':
-      if (event.role === 'assistant') {
-        const text = normalizeMessageContent(event.content);
-        if (text) {
-          return { type: 'text', text };
-        }
-      }
-      return null;
-
-    case 'tool_use': {
-      const toolId = event.tool_call_id || event.tool_id || event.id || state.lastToolId;
-      const toolName = event.tool_name || event.name;
-      state.lastToolId = toolId;
-      return {
-        type: 'tool_call',
-        toolName,
-        toolId,
-        input: event.parameters || event.input || {},
-      };
-    }
-
-    case 'tool_result': {
-      const toolId = event.tool_call_id || event.tool_id || event.id || state.lastToolId;
-      return {
-        type: 'tool_result',
-        toolId,
-        content: event.output ?? event.content ?? '',
-        isError: event.success === false,
-      };
-    }
-
+      return parseMessageEvent(event);
+    case 'tool_use':
+      return parseToolUseEvent(event, state);
+    case 'tool_result':
+      return parseToolResultEvent(event, state);
     case 'result':
-      return {
-        type: 'result',
-        success: event.success !== false,
-        result: event.result || '',
-        error: event.success === false ? event.error || 'Result failed' : null,
-      };
-
+      return parseResultEvent(event);
     default:
       if (options.onUnknown) {
         options.onUnknown(event.type, event);