@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/legacy-lib/run-plan.ts

@@ -0,0 +1,49 @@
+/**
+ * The single canonical run-mode resolver.
+ *
+ * Every consumer (orchestrator, daemon startup, CLI label) derives isolation,
+ * delivery, and autoMerge from THIS function and nowhere else. The raw
+ * worktree/docker/pr/ship/autoMerge booleans are inputs; the frozen plan is the
+ * one truth. Deriving autoMerge separately (the old `Boolean(ship)` scatter) is
+ * what let `--pr` merge and let the run-mode label drift from behavior.
+ */
+
+type RunIsolation = 'none' | 'worktree' | 'docker';
+type RunDelivery = 'none' | 'pr' | 'ship';
+
+interface RunOptions {
+  worktree?: unknown;
+  docker?: unknown;
+  pr?: unknown;
+  ship?: unknown;
+  autoMerge?: unknown;
+}
+
+interface RunPlan {
+  isolation: RunIsolation;
+  delivery: RunDelivery;
+  autoMerge: boolean;
+}
+
+function resolveIsolation(options: RunOptions): RunIsolation {
+  if (options.docker) return 'docker';
+  if (options.worktree || options.pr || options.ship) return 'worktree';
+  return 'none';
+}
+
+function resolveDelivery(options: RunOptions): RunDelivery {
+  // Explicit autoMerge (e.g. a future `--auto-merge` flag) is ship-equivalent:
+  // "merge it" implies the ship delivery. This is the ONLY place that intent is
+  // interpreted, so it can never be silently overwritten downstream.
+  if (options.ship || options.autoMerge === true) return 'ship';
+  if (options.pr) return 'pr';
+  return 'none';
+}
+
+function resolveRunPlan(options: RunOptions = {}): Readonly<RunPlan> {
+  const isolation = resolveIsolation(options);
+  const delivery = resolveDelivery(options);
+  return Object.freeze({ isolation, delivery, autoMerge: delivery === 'ship' });
+}
+
+export = { resolveRunPlan };

package/src/legacy-lib/settings/claude-auth.ts

@@ -0,0 +1,80 @@
+/**
+ * Claude authentication settings and helpers
+ * Extracted from settings.js for provider-specific isolation
+ */
+
+import providerNames = require('../provider-names');
+
+interface ClaudeProviderSettings {
+  readonly anthropicApiKey?: string;
+  readonly bedrockApiKey?: string;
+  readonly bedrockRegion?: string;
+}
+
+interface Settings {
+  readonly providerSettings?: {
+    readonly claude?: ClaudeProviderSettings;
+  };
+}
+
+/**
+ * Anthropic API key prefix for validation
+ */
+const ANTHROPIC_KEY_PREFIX = 'sk-ant-';
+
+/**
+ * Environment variables used for Claude authentication
+ */
+const CLAUDE_AUTH_ENV_VARS = [
+  ...providerNames.getProviderMetadata('claude').docker.envPassthrough,
+];
+
+/**
+ * Validate an Anthropic API key format
+ */
+function isValidAnthropicKey(key: string | null | undefined): boolean {
+  return !key || key.startsWith(ANTHROPIC_KEY_PREFIX);
+}
+
+/**
+ * Check if Bedrock mode is active based on env and overrides
+ */
+function isBedrockMode(envOverrides: NodeJS.ProcessEnv = {}): boolean {
+  return (
+    envOverrides.CLAUDE_CODE_USE_BEDROCK === '1' || process.env.CLAUDE_CODE_USE_BEDROCK === '1'
+  );
+}
+
+/**
+ * Resolve Claude authentication environment variables from settings.
+ * Bedrock takes priority over direct Anthropic API key and OAuth sessions.
+ */
+function resolveClaudeAuth(settings: Settings): NodeJS.ProcessEnv {
+  const claudeSettings = settings.providerSettings?.claude || {};
+  const env: NodeJS.ProcessEnv = {};
+
+  if (!process.env.AWS_BEARER_TOKEN_BEDROCK && claudeSettings.bedrockApiKey) {
+    env.AWS_BEARER_TOKEN_BEDROCK = claudeSettings.bedrockApiKey;
+    env.CLAUDE_CODE_USE_BEDROCK = '1';
+    if (claudeSettings.bedrockRegion && !process.env.AWS_REGION) {
+      env.AWS_REGION = claudeSettings.bedrockRegion;
+    }
+  } else if (process.env.AWS_BEARER_TOKEN_BEDROCK && !process.env.CLAUDE_CODE_USE_BEDROCK) {
+    env.CLAUDE_CODE_USE_BEDROCK = '1';
+  }
+
+  const hasBedrock = env.AWS_BEARER_TOKEN_BEDROCK || process.env.AWS_BEARER_TOKEN_BEDROCK;
+  if (!process.env.ANTHROPIC_API_KEY && !hasBedrock && claudeSettings.anthropicApiKey) {
+    env.ANTHROPIC_API_KEY = claudeSettings.anthropicApiKey;
+  }
+
+  return env;
+}
+
+export = {
+  ANTHROPIC_KEY_PREFIX,
+  CLAUDE_AUTH_ENV_VARS,
+  isValidAnthropicKey,
+  isBedrockMode,
+  resolveClaudeAuth,
+};

package/src/legacy-lib/settings-defaults.ts

@@ -0,0 +1,212 @@
+interface ProviderLevelSettings extends Record<string, unknown> {
+  levelOverrides?: Record<string, unknown>;
+}
+
+type ProviderSettingsRecord = Record<string, ProviderLevelSettings>;
+
+interface SettingsRecord extends Record<string, unknown> {
+  autoCheckUpdates?: unknown;
+  defaultDocker?: unknown;
+  defaultIsolation?: unknown;
+  defaultProvider?: unknown;
+  lastUpdateCheckClaim?: unknown;
+  providerSettings?: ProviderSettingsRecord;
+}
+
+interface ProviderDefaultsFacade {
+  getProviderDefaults(): ProviderSettingsRecord;
+}
+
+interface ProviderNamesFacade {
+  VALID_PROVIDERS: readonly string[];
+  getDefaultProviderId(): string;
+  normalizeProviderName<T>(name: T): T | string;
+  normalizeProviderSettings<T>(settings: T): T | Record<string, unknown>;
+}
+
+interface SettingsModelsFacade {
+  applyLegacyModelBounds(settings: SettingsRecord): SettingsRecord;
+}
+
+interface IssueProviderLoaderFacade {
+  getIssueProviderFns(): {
+    getIssueProviderSettingsDefaults(): SettingsRecord;
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const providerDefaults: ProviderDefaultsFacade = require('./provider-defaults');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const providerNames: ProviderNamesFacade = require('./provider-names');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const settingsModels: SettingsModelsFacade = require('./settings-models');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const issueProviders: IssueProviderLoaderFacade = require('./settings-issue-providers');
+
+const { getProviderDefaults } = providerDefaults;
+const {
+  VALID_PROVIDERS,
+  getDefaultProviderId,
+  normalizeProviderName,
+  normalizeProviderSettings,
+} = providerNames;
+const { applyLegacyModelBounds } = settingsModels;
+const { getIssueProviderFns } = issueProviders;
+
+const DEFAULT_SETTINGS_BASE: SettingsRecord = {
+  maxModel: 'opus',
+  minModel: null,
+  defaultProvider: getDefaultProviderId(),
+  get providerSettings(): ProviderSettingsRecord {
+    return getProviderDefaults();
+  },
+  defaultConfig: 'conductor-bootstrap',
+  defaultIsolation: 'none',
+  defaultDelivery: 'none',
+  setupVersion: null,
+  strictSchema: true,
+  logLevel: 'normal',
+  autoCheckUpdates: true,
+  lastUpdateCheckAt: null,
+  lastSeenVersion: null,
+  lastUpdateCheckClaim: null,
+  claudeCommand: 'claude',
+  dockerMounts: ['gh', 'git', 'ssh'],
+  dockerEnvPassthrough: [],
+  dockerContainerHome: '/home/node',
+  maxRetries: 3,
+  maxRestartAttempts: 3,
+  maxTotalRestarts: 10,
+  staleWarningsBeforeKill: 2,
+  backoffBaseMs: 2000,
+  backoffMaxMs: 30000,
+  jitterFactor: 0.2,
+  defaultIssueSource: 'github',
+};
+
+let defaultSettingsCache: SettingsRecord | null = null;
+
+function getDefaultSettings(): SettingsRecord {
+  if (!defaultSettingsCache) {
+    const issueProviderSettings = getIssueProviderFns().getIssueProviderSettingsDefaults();
+    defaultSettingsCache = {
+      ...DEFAULT_SETTINGS_BASE,
+      ...issueProviderSettings,
+    };
+  }
+  return defaultSettingsCache;
+}
+
+function propertyValue(settings: SettingsRecord, property: PropertyKey): unknown {
+  return typeof property === 'string' ? settings[property] : undefined;
+}
+
+const DEFAULT_SETTINGS: SettingsRecord = new Proxy(DEFAULT_SETTINGS_BASE, {
+  get(target, property): unknown {
+    if (property in target) {
+      return propertyValue(target, property);
+    }
+    return propertyValue(getDefaultSettings(), property);
+  },
+  has(target, property): boolean {
+    if (property in target) return true;
+    return property in getDefaultSettings();
+  },
+  ownKeys(): string[] {
+    return Object.keys(getDefaultSettings());
+  },
+  getOwnPropertyDescriptor(_target, property): PropertyDescriptor | undefined {
+    const merged = getDefaultSettings();
+    if (property in merged) {
+      return { enumerable: true, configurable: true, value: propertyValue(merged, property) };
+    }
+    return undefined;
+  },
+});
+
+function isUnknownRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function providerOverride(value: unknown, provider: string): Record<string, unknown> {
+  if (!isUnknownRecord(value)) return {};
+  const selected = value[provider];
+  return isUnknownRecord(selected) ? selected : {};
+}
+
+function mergeProviderSettings(
+  current: ProviderSettingsRecord,
+  overrides?: unknown
+): ProviderSettingsRecord {
+  const providerDefaultsValue = getProviderDefaults();
+  const merged: ProviderSettingsRecord = {};
+
+  for (const provider of VALID_PROVIDERS) {
+    merged[provider] = {
+      ...(providerDefaultsValue[provider] || {}),
+      ...(current[provider] || {}),
+      ...providerOverride(overrides, provider),
+    };
+    if (!merged[provider].levelOverrides) {
+      merged[provider].levelOverrides = {};
+    }
+  }
+  return merged;
+}
+
+function normalizeLoadedSettings(parsed: SettingsRecord): SettingsRecord {
+  const normalized = { ...parsed };
+  if (!Object.hasOwn(parsed, 'defaultIsolation') && typeof parsed.defaultDocker === 'boolean') {
+    normalized.defaultIsolation = parsed.defaultDocker ? 'docker' : 'none';
+  }
+  delete normalized.defaultDocker;
+  if (parsed.defaultProvider) {
+    normalized.defaultProvider = normalizeProviderName(parsed.defaultProvider);
+  }
+  if (parsed.providerSettings) {
+    const normalizedProviders = normalizeProviderSettings(parsed.providerSettings);
+    if (isProviderSettingsRecord(normalizedProviders)) {
+      normalized.providerSettings = normalizedProviders;
+    }
+  }
+  if (
+    normalized.autoCheckUpdates === false ||
+    typeof normalized.lastUpdateCheckClaim !== 'string' ||
+    normalized.lastUpdateCheckClaim.trim().length === 0
+  ) {
+    normalized.lastUpdateCheckClaim = null;
+  }
+  return normalized;
+}
+
+function isProviderSettingsRecord(value: unknown): value is ProviderSettingsRecord {
+  return isUnknownRecord(value);
+}
+
+function resolvedDefaultSettings(): SettingsRecord {
+  return {
+    ...DEFAULT_SETTINGS,
+    providerSettings: mergeProviderSettings(getProviderDefaults()),
+  };
+}
+
+function mergeLoadedSettings(parsed: SettingsRecord): SettingsRecord {
+  const normalized = normalizeLoadedSettings(parsed);
+  const merged = { ...resolvedDefaultSettings(), ...normalized };
+  merged.defaultProvider =
+    normalizeProviderName(merged.defaultProvider) || DEFAULT_SETTINGS.defaultProvider;
+  merged.providerSettings = mergeProviderSettings(
+    getProviderDefaults(),
+    normalized.providerSettings
+  );
+  if (
+    merged.autoCheckUpdates === false ||
+    typeof merged.lastUpdateCheckClaim !== 'string' ||
+    merged.lastUpdateCheckClaim.trim().length === 0
+  ) {
+    merged.lastUpdateCheckClaim = null;
+  }
+  return applyLegacyModelBounds(merged);
+}
+
+export = { DEFAULT_SETTINGS, resolvedDefaultSettings, mergeLoadedSettings };

package/src/legacy-lib/settings-error.ts

@@ -0,0 +1,8 @@
+class SettingsValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'SettingsValidationError';
+  }
+}
+
+export = { SettingsValidationError };

package/src/legacy-lib/settings-issue-providers.ts

@@ -0,0 +1,18 @@
+interface IssueProviderFacade {
+  getIssueProviderSettingsDefaults(): Record<string, unknown>;
+  listProviders(): readonly string[];
+  validateIssueProviderSetting(key: string, value: unknown): string | null | undefined;
+}
+
+let issueProviderFns: IssueProviderFacade | null = null;
+
+function getIssueProviderFns(): IssueProviderFacade {
+  if (issueProviderFns) return issueProviderFns;
+  // Lazy load preserves the issue-providers -> settings -> issue-providers boundary.
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const loaded: IssueProviderFacade = require('../src/issue-providers');
+  issueProviderFns = loaded;
+  return loaded;
+}
+
+export = { getIssueProviderFns };

package/src/legacy-lib/settings-models.ts

@@ -0,0 +1,124 @@
+type ModelLevel = 'level1' | 'level2' | 'level3';
+
+interface ProviderLevelSettings extends Record<string, unknown> {
+  defaultLevel?: ModelLevel;
+  maxLevel?: ModelLevel;
+  minLevel?: ModelLevel;
+}
+
+interface SettingsRecord extends Record<string, unknown> {
+  maxModel?: string | null;
+  minModel?: string | null;
+  providerSettings?: Record<string, ProviderLevelSettings>;
+}
+
+const MODEL_HIERARCHY: Readonly<Record<string, number>> = Object.freeze({
+  opus: 3,
+  fable: 3,
+  sonnet: 2,
+  haiku: 1,
+});
+
+const VALID_MODELS = Object.keys(MODEL_HIERARCHY);
+const LEVEL_RANKS: Readonly<Record<ModelLevel, number>> = Object.freeze({
+  level1: 1,
+  level2: 2,
+  level3: 3,
+});
+
+function validateModelAgainstMax(
+  requestedModel: string | null | undefined,
+  maxModel: string,
+  minModel: string | null = null
+): string {
+  if (!requestedModel) return maxModel;
+
+  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(', ')}`);
+  }
+
+  const requestedRank = MODEL_HIERARCHY[requestedModel] ?? 0;
+  const maximumRank = MODEL_HIERARCHY[maxModel] ?? 0;
+  if (requestedRank > maximumRank) {
+    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(', ')}`);
+    }
+    const minimumRank = MODEL_HIERARCHY[minModel] ?? 0;
+    if (minimumRank > maximumRank) {
+      throw new Error(`minModel "${minModel}" cannot be higher than maxModel "${maxModel}".`);
+    }
+    if (requestedRank < minimumRank) {
+      throw new Error(
+        `Agent requests "${requestedModel}" but minModel is "${minModel}". ` +
+          `Either raise agent's model or lower minModel.`
+      );
+    }
+  }
+
+  return requestedModel;
+}
+
+function mapLegacyModelToLevel(model: unknown): ModelLevel | null {
+  switch (model) {
+    case 'haiku':
+      return 'level1';
+    case 'sonnet':
+      return 'level2';
+    case 'opus':
+      return 'level3';
+    default:
+      return null;
+  }
+}
+
+function levelRank(level: ModelLevel | undefined, fallback: ModelLevel): number {
+  return LEVEL_RANKS[level ?? fallback];
+}
+
+function applyLegacyModelBounds(settings: SettingsRecord): SettingsRecord {
+  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 = levelRank(claude.minLevel, 'level1');
+  const maxRank = levelRank(claude.maxLevel, 'level3');
+  const defaultRank = levelRank(claude.defaultLevel, 'level2');
+
+  if (minRank > maxRank) {
+    claude.minLevel = 'level1';
+    claude.maxLevel = 'level3';
+  } else if (defaultRank < minRank && claude.minLevel !== undefined) {
+    claude.defaultLevel = claude.minLevel;
+  } else if (defaultRank > maxRank && claude.maxLevel !== undefined) {
+    claude.defaultLevel = claude.maxLevel;
+  }
+
+  settings.providerSettings.claude = claude;
+  return settings;
+}
+
+export = {
+  MODEL_HIERARCHY,
+  VALID_MODELS,
+  validateModelAgainstMax,
+  mapLegacyModelToLevel,
+  applyLegacyModelBounds,
+};