@covibes/zeroshot 5.3.0 → 5.4.1

package/lib/settings.js

@@ -1,405 +0,0 @@
-/**
- * Settings management for zeroshot
- * Persistent user preferences stored in ~/.zeroshot/settings.json
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { validateMountConfig, validateEnvPassthrough } = require('./docker-config');
-const {
-  VALID_PROVIDERS,
-  normalizeProviderName,
-  normalizeProviderSettings,
-} = require('./provider-names');
-
-/**
- * Get settings file path (dynamically reads env var for testing)
- * Using a getter ensures tests can override the path at runtime
- * @returns {string}
- */
-function getSettingsFile() {
-  return (
-    process.env.ZEROSHOT_SETTINGS_FILE || path.join(os.homedir(), '.zeroshot', 'settings.json')
-  );
-}
-
-/**
- * Model hierarchy for cost ceiling validation
- * Higher number = more expensive/capable model
- */
-const MODEL_HIERARCHY = {
-  opus: 3,
-  sonnet: 2,
-  haiku: 1,
-};
-
-const VALID_MODELS = Object.keys(MODEL_HIERARCHY);
-const LEVEL_RANKS = { level1: 1, level2: 2, level3: 3 };
-
-/**
- * Validate a requested model against the maxModel ceiling and minModel floor
- * @param {string} requestedModel - Model the agent wants to use
- * @param {string} maxModel - Maximum allowed model (cost ceiling)
- * @param {string|null} minModel - Minimum required model (cost floor)
- * @returns {string} The validated model
- * @throws {Error} If requested model exceeds ceiling or falls below floor
- */
-function validateModelAgainstMax(requestedModel, maxModel, minModel = null) {
-  if (!requestedModel) return maxModel; // Default to ceiling if unspecified
-
-  if (!VALID_MODELS.includes(requestedModel)) {
-    throw new Error(`Invalid model "${requestedModel}". Valid: ${VALID_MODELS.join(', ')}`);
-  }
-  if (!VALID_MODELS.includes(maxModel)) {
-    throw new Error(`Invalid maxModel "${maxModel}". Valid: ${VALID_MODELS.join(', ')}`);
-  }
-
-  if (MODEL_HIERARCHY[requestedModel] > MODEL_HIERARCHY[maxModel]) {
-    throw new Error(
-      `Agent requests "${requestedModel}" but maxModel is "${maxModel}". ` +
-        `Either lower agent's model or raise maxModel.`
-    );
-  }
-
-  if (minModel) {
-    if (!VALID_MODELS.includes(minModel)) {
-      throw new Error(`Invalid minModel "${minModel}". Valid: ${VALID_MODELS.join(', ')}`);
-    }
-    if (MODEL_HIERARCHY[minModel] > MODEL_HIERARCHY[maxModel]) {
-      throw new Error(`minModel "${minModel}" cannot be higher than maxModel "${maxModel}".`);
-    }
-    if (MODEL_HIERARCHY[requestedModel] < MODEL_HIERARCHY[minModel]) {
-      throw new Error(
-        `Agent requests "${requestedModel}" but minModel is "${minModel}". ` +
-          `Either raise agent's model or lower minModel.`
-      );
-    }
-  }
-
-  return requestedModel;
-}
-
-// Default settings
-const DEFAULT_SETTINGS = {
-  maxModel: 'opus', // Cost ceiling - agents cannot use models above this
-  minModel: null, // Cost floor - agents cannot use models below this (null = no minimum)
-  defaultProvider: 'claude',
-  providerSettings: {
-    claude: {
-      maxLevel: 'level3',
-      minLevel: 'level1',
-      defaultLevel: 'level2',
-      levelOverrides: {},
-    },
-    codex: {
-      maxLevel: 'level3',
-      minLevel: 'level1',
-      defaultLevel: 'level2',
-      levelOverrides: {},
-    },
-    gemini: {
-      maxLevel: 'level3',
-      minLevel: 'level1',
-      defaultLevel: 'level2',
-      levelOverrides: {},
-    },
-  },
-  defaultConfig: 'conductor-bootstrap',
-  defaultDocker: false,
-  strictSchema: true, // true = reliable json output (default), false = live streaming (may crash - see bold-meadow-11)
-  logLevel: 'normal',
-  // Auto-update settings
-  autoCheckUpdates: true, // Check npm registry for newer versions
-  lastUpdateCheckAt: null, // Unix timestamp of last check (null = never checked)
-  lastSeenVersion: null, // Don't re-prompt for same version
-  // Claude command - customize how to invoke Claude CLI (default: 'claude')
-  // Example: 'ccr code' for claude-code-router integration
-  claudeCommand: 'claude',
-  // Docker isolation mounts - preset names or {host, container, readonly?} objects
-  // Valid presets: gh, git, ssh, aws, azure, kube, terraform, gcloud, claude, codex, gemini
-  dockerMounts: ['gh', 'git', 'ssh'],
-  // Extra env vars to pass to Docker container (in addition to preset-implied ones)
-  // Supports: VAR (if set), VAR_* (pattern), VAR=value (forced), VAR= (empty)
-  dockerEnvPassthrough: [],
-  // Container home directory - where $HOME resolves in container paths
-  // Default: /home/node (matches zeroshot-cluster-base image)
-  dockerContainerHome: '/home/node',
-};
-
-function mapLegacyModelToLevel(model) {
-  switch (model) {
-    case 'haiku':
-      return 'level1';
-    case 'sonnet':
-      return 'level2';
-    case 'opus':
-      return 'level3';
-    default:
-      return null;
-  }
-}
-
-function mergeProviderSettings(current, overrides) {
-  const merged = { ...current };
-  for (const provider of VALID_PROVIDERS) {
-    merged[provider] = {
-      ...current[provider],
-      ...(overrides?.[provider] || {}),
-    };
-    if (!merged[provider].levelOverrides) {
-      merged[provider].levelOverrides = {};
-    }
-  }
-  return merged;
-}
-
-function applyLegacyModelBounds(settings) {
-  if (!settings.providerSettings) return settings;
-  const claude = settings.providerSettings.claude || {};
-  const legacyMaxLevel = mapLegacyModelToLevel(settings.maxModel);
-  const legacyMinLevel = mapLegacyModelToLevel(settings.minModel);
-
-  if (legacyMaxLevel) {
-    claude.maxLevel = legacyMaxLevel;
-  }
-
-  if (legacyMinLevel) {
-    claude.minLevel = legacyMinLevel;
-  }
-
-  const minRank = LEVEL_RANKS[claude.minLevel] || LEVEL_RANKS.level1;
-  const maxRank = LEVEL_RANKS[claude.maxLevel] || LEVEL_RANKS.level3;
-  const defaultRank = LEVEL_RANKS[claude.defaultLevel] || LEVEL_RANKS.level2;
-
-  if (minRank > maxRank) {
-    claude.minLevel = 'level1';
-    claude.maxLevel = 'level3';
-  } else if (defaultRank < minRank) {
-    claude.defaultLevel = claude.minLevel;
-  } else if (defaultRank > maxRank) {
-    claude.defaultLevel = claude.maxLevel;
-  }
-
-  settings.providerSettings.claude = claude;
-  return settings;
-}
-
-function normalizeLoadedSettings(parsed) {
-  const normalized = { ...parsed };
-  if (parsed.defaultProvider) {
-    normalized.defaultProvider = normalizeProviderName(parsed.defaultProvider);
-  }
-  if (parsed.providerSettings) {
-    normalized.providerSettings = normalizeProviderSettings(parsed.providerSettings);
-  }
-  return normalized;
-}
-
-/**
- * Load settings from disk, merging with defaults
- */
-function loadSettings() {
-  const settingsFile = getSettingsFile();
-  if (!fs.existsSync(settingsFile)) {
-    return { ...DEFAULT_SETTINGS };
-  }
-  try {
-    const data = fs.readFileSync(settingsFile, 'utf8');
-    const parsed = normalizeLoadedSettings(JSON.parse(data));
-    const merged = { ...DEFAULT_SETTINGS, ...parsed };
-    merged.defaultProvider =
-      normalizeProviderName(merged.defaultProvider) || DEFAULT_SETTINGS.defaultProvider;
-    merged.providerSettings = mergeProviderSettings(
-      DEFAULT_SETTINGS.providerSettings,
-      parsed.providerSettings
-    );
-    return applyLegacyModelBounds(merged);
-  } catch {
-    console.error('Warning: Could not load settings, using defaults');
-    return { ...DEFAULT_SETTINGS };
-  }
-}
-
-/**
- * Save settings to disk
- */
-function saveSettings(settings) {
-  const settingsFile = getSettingsFile();
-  const dir = path.dirname(settingsFile);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2), 'utf8');
-}
-
-/**
- * Validate a setting value
- * @returns {string|null} Error message if invalid, null if valid
- */
-function validateSetting(key, value) {
-  if (!(key in DEFAULT_SETTINGS)) {
-    return `Unknown setting: ${key}`;
-  }
-
-  if (key === 'maxModel' && !VALID_MODELS.includes(value)) {
-    return `Invalid model: ${value}. Valid models: ${VALID_MODELS.join(', ')}`;
-  }
-
-  if (key === 'minModel' && value !== null && !VALID_MODELS.includes(value)) {
-    return `Invalid model: ${value}. Valid models: ${VALID_MODELS.join(', ')}, null`;
-  }
-
-  if (key === 'logLevel' && !['quiet', 'normal', 'verbose'].includes(value)) {
-    return `Invalid log level: ${value}. Valid levels: quiet, normal, verbose`;
-  }
-
-  if (key === 'claudeCommand') {
-    if (typeof value !== 'string') {
-      return 'claudeCommand must be a string';
-    }
-    if (value.trim().length === 0) {
-      return 'claudeCommand cannot be empty';
-    }
-  }
-
-  if (key === 'defaultProvider') {
-    const normalized = normalizeProviderName(value);
-    if (!VALID_PROVIDERS.includes(normalized)) {
-      return `Invalid provider: ${value}. Valid providers: ${VALID_PROVIDERS.join(', ')}`;
-    }
-  }
-
-  if (key === 'providerSettings') {
-    const normalizedSettings = normalizeProviderSettings(value);
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-      return 'providerSettings must be an object';
-    }
-    for (const [provider, settings] of Object.entries(normalizedSettings || {})) {
-      if (!VALID_PROVIDERS.includes(provider)) {
-        return `Unknown provider in providerSettings: ${provider}`;
-      }
-      if (typeof settings !== 'object' || settings === null) {
-        return `providerSettings.${provider} must be an object`;
-      }
-      if (settings.maxLevel && !LEVEL_RANKS[settings.maxLevel]) {
-        return `Invalid maxLevel for ${provider}: ${settings.maxLevel}`;
-      }
-      if (settings.minLevel && !LEVEL_RANKS[settings.minLevel]) {
-        return `Invalid minLevel for ${provider}: ${settings.minLevel}`;
-      }
-      if (settings.defaultLevel && !LEVEL_RANKS[settings.defaultLevel]) {
-        return `Invalid defaultLevel for ${provider}: ${settings.defaultLevel}`;
-      }
-      if (
-        settings.levelOverrides &&
-        (typeof settings.levelOverrides !== 'object' || Array.isArray(settings.levelOverrides))
-      ) {
-        return `levelOverrides for ${provider} must be an object`;
-      }
-    }
-  }
-
-  if (key === 'dockerMounts') {
-    return validateMountConfig(value);
-  }
-
-  if (key === 'dockerEnvPassthrough') {
-    return validateEnvPassthrough(value);
-  }
-
-  return null;
-}
-
-/**
- * Coerce value to correct type based on default value type
- */
-function coerceValue(key, value) {
-  const defaultValue = DEFAULT_SETTINGS[key];
-
-  // Handle null values for minModel
-  if (key === 'minModel' && (value === 'null' || value === null)) {
-    return null;
-  }
-
-  if (typeof defaultValue === 'boolean') {
-    return value === 'true' || value === '1' || value === 'yes' || value === true;
-  }
-
-  if (typeof defaultValue === 'number') {
-    const parsed = parseInt(value);
-    if (isNaN(parsed)) {
-      throw new Error(`Invalid number: ${value}`);
-    }
-    return parsed;
-  }
-
-  // Handle array settings (dockerMounts, dockerEnvPassthrough)
-  if (Array.isArray(defaultValue)) {
-    if (typeof value === 'string') {
-      try {
-        const parsed = JSON.parse(value);
-        if (!Array.isArray(parsed)) {
-          throw new Error(`${key} must be an array`);
-        }
-        return parsed;
-      } catch (e) {
-        if (e instanceof SyntaxError) {
-          throw new Error(`Invalid JSON for ${key}: ${value}`);
-        }
-        throw e;
-      }
-    }
-    return value;
-  }
-
-  if (key === 'providerSettings') {
-    if (typeof value === 'string') {
-      try {
-        return normalizeProviderSettings(JSON.parse(value));
-      } catch {
-        throw new Error(`Invalid JSON for providerSettings: ${value}`);
-      }
-    }
-    return normalizeProviderSettings(value);
-  }
-
-  if (key === 'defaultProvider') {
-    return normalizeProviderName(value);
-  }
-
-  return value;
-}
-
-/**
- * Get parsed Claude command from settings/env
- * Supports space-separated commands like 'ccr code'
- * @returns {{ command: string, args: string[] }}
- */
-function getClaudeCommand() {
-  const settings = loadSettings();
-  const raw = process.env.ZEROSHOT_CLAUDE_COMMAND || settings.claudeCommand || 'claude';
-  const parts = raw.trim().split(/\s+/);
-  return {
-    command: parts[0],
-    args: parts.slice(1),
-  };
-}
-
-module.exports = {
-  loadSettings,
-  saveSettings,
-  validateSetting,
-  coerceValue,
-  DEFAULT_SETTINGS,
-  getSettingsFile,
-  getClaudeCommand,
-  // Model validation exports
-  MODEL_HIERARCHY,
-  VALID_MODELS,
-  validateModelAgainstMax,
-  // Backward compatibility: SETTINGS_FILE as getter (reads env var dynamically)
-  get SETTINGS_FILE() {
-    return getSettingsFile();
-  },
-};

package/lib/stream-json-parser.js

@@ -1,10 +0,0 @@
-/**
- * Compatibility wrapper for Claude stream-json parsing.
- * Prefer provider-specific parsers in src/providers.
- */
-const { parseEvent, parseChunk } = require('../src/providers/anthropic/output-parser');
-
-module.exports = {
-  parseEvent,
-  parseChunk,
-};

package/scripts/fix-node-pty-permissions.js

@@ -1,75 +0,0 @@
-#!/usr/bin/env node
-/**
- * Fix node-pty spawn-helper permissions.
- *
- * node-pty prebuilds ship with spawn-helper lacking execute permission (mode 644).
- * This causes "posix_spawnp failed" errors on macOS/Linux.
- *
- * Upstream bug: https://github.com/microsoft/node-pty/issues/XXX
- * (File issue if not already reported)
- *
- * This script runs as postinstall to fix it automatically.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// Skip on Windows - chmod doesn't apply
-if (process.platform === 'win32') {
-  process.exit(0);
-}
-
-const prebuildsDir = path.join(__dirname, '..', 'node_modules', 'node-pty', 'prebuilds');
-
-if (!fs.existsSync(prebuildsDir)) {
-  // node-pty not installed yet or using compiled version
-  process.exit(0);
-}
-
-let fixed = 0;
-let errors = 0;
-
-try {
-  const platforms = fs.readdirSync(prebuildsDir).filter(f => {
-    try {
-      return fs.statSync(path.join(prebuildsDir, f)).isDirectory();
-    } catch {
-      return false;
-    }
-  });
-
-  for (const platform of platforms) {
-    // Only fix Unix platforms (darwin, linux)
-    if (!platform.startsWith('darwin') && !platform.startsWith('linux')) {
-      continue;
-    }
-
-    const helper = path.join(prebuildsDir, platform, 'spawn-helper');
-    try {
-      if (!fs.existsSync(helper)) continue;
-
-      const stat = fs.statSync(helper);
-      // Check if not executable (missing user execute bit)
-      if (!(stat.mode & 0o100)) {
-        fs.chmodSync(helper, 0o755);
-        fixed++;
-      }
-    } catch (err) {
-      // Log but don't fail install - permission fix is best-effort
-      console.warn(`[postinstall] Warning: Could not fix ${helper}: ${err.message}`);
-      errors++;
-    }
-  }
-} catch (err) {
-  // Don't fail install on unexpected errors
-  console.warn(`[postinstall] Warning: node-pty permission fix failed: ${err.message}`);
-  process.exit(0);
-}
-
-if (fixed > 0) {
-  console.log(`[postinstall] Fixed node-pty spawn-helper permissions (${fixed} platform(s))`);
-}
-
-if (errors > 0) {
-  console.warn(`[postinstall] ${errors} platform(s) could not be fixed - may need manual chmod`);
-}