@the-open-engine/zeroshot 6.38.1 → 6.39.0

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

@@ -0,0 +1,277 @@
+import crypto = require('crypto');
+import fs = require('fs');
+import os = require('os');
+import path = require('path');
+
+interface SettingsRecord extends Record<string, unknown> {
+  autoCheckUpdates?: unknown;
+  lastUpdateCheckClaim?: unknown;
+  updatePolicy?: unknown;
+}
+
+interface DefaultsFacade {
+  resolvedDefaultSettings(): SettingsRecord;
+  mergeLoadedSettings(parsed: SettingsRecord): SettingsRecord;
+}
+
+interface LockOptions {
+  lockfilePath: string;
+  realpath: boolean;
+  stale: number;
+}
+
+interface LockfileFacade {
+  lockSync(settingsFile: string, options: LockOptions): ReleaseLock;
+}
+
+interface LoadOptions {
+  silent?: unknown;
+}
+
+interface MutationOptions {
+  lockTimeoutMs?: number;
+}
+
+interface MutationState {
+  settings: SettingsRecord;
+  requiresClaimInvalidation: boolean;
+  requiresRecovery: boolean;
+}
+
+type SettingsMutator = (settings: SettingsRecord) => unknown;
+type ReleaseLock = () => void;
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const lockfile: LockfileFacade = require('proper-lockfile');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const defaults: DefaultsFacade = require('./settings-defaults');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { SettingsValidationError }: { SettingsValidationError: typeof Error } =
+  require('./settings-error');
+
+const { resolvedDefaultSettings, mergeLoadedSettings } = defaults;
+const SETTINGS_LOCK_STALE_MS = 5000;
+const SETTINGS_LOCK_TIMEOUT_MS = 500;
+const SETTINGS_LOCK_RETRY_MS = 20;
+const SETTINGS_LOCK_SLEEP = new Int32Array(new SharedArrayBuffer(4));
+
+function isSettingsRecord(value: unknown): value is SettingsRecord {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function errorCode(error: unknown): unknown {
+  return error !== null && typeof error === 'object' && 'code' in error ? error.code : undefined;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    'then' in value &&
+    typeof value.then === 'function'
+  );
+}
+
+function getSettingsFile(): string {
+  return (
+    process.env.ZEROSHOT_SETTINGS_FILE || path.join(os.homedir(), '.zeroshot', 'settings.json')
+  );
+}
+
+function settingsFileExists(): boolean {
+  return fs.existsSync(getSettingsFile());
+}
+
+function loadSettings(options: LoadOptions = {}): SettingsRecord {
+  const settingsFile = getSettingsFile();
+  if (!fs.existsSync(settingsFile)) {
+    return resolvedDefaultSettings();
+  }
+  try {
+    const parsed: unknown = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
+    if (!isSettingsRecord(parsed)) {
+      throw new TypeError('settings file must contain an object');
+    }
+    return mergeLoadedSettings(parsed);
+  } catch {
+    if (!options.silent) console.error('Warning: Could not load settings, using defaults');
+    return resolvedDefaultSettings();
+  }
+}
+
+function readSettingsForMutation(settingsFile: string): MutationState {
+  if (!fs.existsSync(settingsFile)) {
+    return {
+      settings: resolvedDefaultSettings(),
+      requiresClaimInvalidation: false,
+      requiresRecovery: false,
+    };
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
+  } catch (error: unknown) {
+    if (!(error instanceof SyntaxError)) throw error;
+    return {
+      settings: resolvedDefaultSettings(),
+      requiresClaimInvalidation: false,
+      requiresRecovery: true,
+    };
+  }
+  if (!isSettingsRecord(parsed)) {
+    return {
+      settings: resolvedDefaultSettings(),
+      requiresClaimInvalidation: false,
+      requiresRecovery: true,
+    };
+  }
+
+  const updatesDisabled = parsed.autoCheckUpdates === false || parsed.updatePolicy === 'off';
+  return {
+    settings: mergeLoadedSettings(parsed),
+    requiresClaimInvalidation: updatesDisabled && parsed.lastUpdateCheckClaim !== null,
+    requiresRecovery: false,
+  };
+}
+
+function getAtomicSettingsMode(settingsFile: string): number {
+  try {
+    return fs.statSync(settingsFile).mode & 0o600;
+  } catch (error: unknown) {
+    if (errorCode(error) === 'ENOENT') return 0o600;
+    throw error;
+  }
+}
+
+function atomicWriteSettings(settingsFile: string, settings: SettingsRecord): void {
+  const dir = path.dirname(settingsFile);
+  const temporaryFile = path.join(
+    dir,
+    `.${path.basename(settingsFile)}.${process.pid}.${crypto.randomUUID()}.tmp`
+  );
+
+  let operationError: unknown;
+  try {
+    fs.writeFileSync(temporaryFile, JSON.stringify(settings, null, 2), {
+      encoding: 'utf8',
+      flag: 'wx',
+      mode: getAtomicSettingsMode(settingsFile),
+    });
+    fs.renameSync(temporaryFile, settingsFile);
+  } catch (error: unknown) {
+    operationError = error;
+  }
+
+  try {
+    fs.unlinkSync(temporaryFile);
+  } catch (error: unknown) {
+    if (errorCode(error) !== 'ENOENT' && !operationError) operationError = error;
+  }
+  if (operationError) throw operationError;
+}
+
+function acquireSettingsLock(
+  settingsFile: string,
+  lockfilePath: string,
+  timeoutMs: number
+): ReleaseLock {
+  const deadline = Date.now() + timeoutMs;
+  return tryAcquireSettingsLock(settingsFile, lockfilePath, deadline);
+}
+
+function shouldRetrySettingsLock(error: unknown, deadline: number): boolean {
+  return errorCode(error) === 'ELOCKED' && Date.now() < deadline;
+}
+
+function tryAcquireSettingsLock(
+  settingsFile: string,
+  lockfilePath: string,
+  deadline: number
+): ReleaseLock {
+  try {
+    return lockfile.lockSync(settingsFile, {
+      lockfilePath,
+      realpath: false,
+      stale: SETTINGS_LOCK_STALE_MS,
+    });
+  } catch (error: unknown) {
+    if (!shouldRetrySettingsLock(error, deadline)) throw error;
+    Atomics.wait(SETTINGS_LOCK_SLEEP, 0, 0, SETTINGS_LOCK_RETRY_MS);
+    return tryAcquireSettingsLock(settingsFile, lockfilePath, deadline);
+  }
+}
+
+function applySettingsMutation(settingsFile: string, mutator: SettingsMutator): unknown {
+  const { settings, requiresClaimInvalidation, requiresRecovery } =
+    readSettingsForMutation(settingsFile);
+  const before = JSON.stringify(settings);
+  const result = mutator(settings);
+  if (isPromiseLike(result)) {
+    throw new TypeError('Global settings mutations must be synchronous');
+  }
+  if (settings.autoCheckUpdates === false || settings.updatePolicy === 'off') {
+    settings.lastUpdateCheckClaim = null;
+  }
+  if (requiresRecovery || requiresClaimInvalidation || JSON.stringify(settings) !== before) {
+    atomicWriteSettings(settingsFile, settings);
+  }
+  return result;
+}
+
+function asMutationError(error: unknown): Error {
+  return error instanceof SettingsValidationError
+    ? error
+    : new Error(`Unable to persist global settings: ${errorMessage(error)}`, { cause: error });
+}
+
+function releaseSettingsLock(
+  release: ReleaseLock | undefined,
+  mutationError: Error | undefined
+): Error | undefined {
+  if (!release) return mutationError;
+  try {
+    release();
+    return mutationError;
+  } catch (error: unknown) {
+    return (
+      mutationError ||
+      new Error(`Unable to release global settings lock: ${errorMessage(error)}`, { cause: error })
+    );
+  }
+}
+
+function mutateSettings(mutator: SettingsMutator, options: MutationOptions = {}): unknown {
+  if (typeof mutator !== 'function') {
+    throw new TypeError('Global settings mutation requires a callback');
+  }
+
+  const settingsFile = getSettingsFile();
+  const dir = path.dirname(settingsFile);
+  const lockfilePath = `${settingsFile}.lock`;
+  let release: ReleaseLock | undefined;
+  let result: unknown;
+  let mutationError: Error | undefined;
+
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    release = acquireSettingsLock(
+      settingsFile,
+      lockfilePath,
+      options.lockTimeoutMs ?? SETTINGS_LOCK_TIMEOUT_MS
+    );
+
+    result = applySettingsMutation(settingsFile, mutator);
+  } catch (error: unknown) {
+    mutationError = asMutationError(error);
+  } finally {
+    mutationError = releaseSettingsLock(release, mutationError);
+  }
+  if (mutationError) throw mutationError;
+  return result;
+}
+
+export = { loadSettings, mutateSettings, getSettingsFile, settingsFileExists };

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

@@ -0,0 +1,220 @@
+interface SettingsRecord extends Record<string, unknown> {}
+
+interface DockerConfigFacade {
+  validateMountConfig(value: unknown): string | null;
+  validateEnvPassthrough(value: unknown): string | null;
+}
+
+interface ProviderNamesFacade {
+  VALID_PROVIDERS: readonly string[];
+  normalizeProviderName<T>(name: T): T | string;
+  normalizeProviderSettings<T>(settings: T): T | Record<string, unknown>;
+}
+
+interface DefaultsFacade {
+  DEFAULT_SETTINGS: SettingsRecord;
+}
+
+interface ModelsFacade {
+  VALID_MODELS: readonly string[];
+}
+
+interface ProviderFacade {
+  validateSettings(settings: unknown): string | null;
+}
+
+interface ProvidersFacade {
+  getProvider(providerId: string): ProviderFacade;
+}
+
+interface IssueProviderLoaderFacade {
+  getIssueProviderFns(): {
+    listProviders(): readonly string[];
+    validateIssueProviderSetting(key: string, value: unknown): string | null | undefined;
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const dockerConfig: DockerConfigFacade = require('./docker-config');
+// 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 defaults: DefaultsFacade = require('./settings-defaults');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const models: ModelsFacade = require('./settings-models');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const issueProviders: IssueProviderLoaderFacade = require('./settings-issue-providers');
+
+const { validateMountConfig, validateEnvPassthrough } = dockerConfig;
+const { VALID_PROVIDERS, normalizeProviderName, normalizeProviderSettings } = providerNames;
+const { DEFAULT_SETTINGS } = defaults;
+const { VALID_MODELS } = models;
+const { getIssueProviderFns } = issueProviders;
+
+function isUnknownRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function includesUnknown(values: readonly unknown[], value: unknown): boolean {
+  return values.includes(value);
+}
+
+function validateClaudeCommand(value: unknown): string | null {
+  if (typeof value !== 'string') {
+    return 'claudeCommand must be a string';
+  }
+  if (value.trim().length === 0) {
+    return 'claudeCommand cannot be empty';
+  }
+  return null;
+}
+
+function validateProviderSettings(value: unknown): string | null {
+  const normalizedSettings = normalizeProviderSettings(value);
+  if (!isUnknownRecord(value)) {
+    return 'providerSettings must be an object';
+  }
+
+  if (!isUnknownRecord(normalizedSettings)) {
+    return 'providerSettings must be an object';
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const providers: ProvidersFacade = require('../src/providers');
+  for (const [providerName, settings] of Object.entries(normalizedSettings)) {
+    if (!VALID_PROVIDERS.includes(providerName)) {
+      return `Unknown provider in providerSettings: ${providerName}. Valid providers: ${VALID_PROVIDERS.join(', ')}`;
+    }
+
+    try {
+      const provider = providers.getProvider(providerName);
+      const error = provider.validateSettings(settings);
+      if (error) return error;
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      return `Failed to validate ${providerName} settings: ${message}`;
+    }
+  }
+  return null;
+}
+
+function validateIssueSourceSetting(key: string, value: unknown): string | null | undefined {
+  if (key === 'defaultIssueSource') {
+    const validSources = getIssueProviderFns().listProviders();
+    if (!includesUnknown(validSources, value)) {
+      return `Invalid issue source: ${String(value)}. Valid: ${validSources.join(', ')}`;
+    }
+    return null;
+  }
+  return getIssueProviderFns().validateIssueProviderSetting(key, value);
+}
+
+const POSITIVE_INTEGER_SETTINGS = [
+  'maxRetries',
+  'maxRestartAttempts',
+  'maxTotalRestarts',
+  'staleWarningsBeforeKill',
+  'backoffBaseMs',
+  'backoffMaxMs',
+];
+
+function validateNumberSetting(key: string, value: unknown): string | null {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return `${key} must be a number`;
+  }
+  if (!Number.isInteger(value)) {
+    return `${key} must be an integer`;
+  }
+  const min = ['backoffBaseMs', 'backoffMaxMs'].includes(key) ? 0 : 1;
+  return value < min ? `${key} must be >= ${min}` : null;
+}
+
+function validateSetting(key: string, value: unknown): string | null {
+  if (!(key in DEFAULT_SETTINGS)) {
+    return `Unknown setting: ${key}`;
+  }
+
+  if (POSITIVE_INTEGER_SETTINGS.includes(key)) {
+    const error = validateNumberSetting(key, value);
+    if (error) return error;
+  }
+  if (key === 'jitterFactor') {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+      return 'jitterFactor must be a number';
+    }
+    if (value < 0 || value > 1) {
+      return 'jitterFactor must be between 0 and 1';
+    }
+  }
+  if (key === 'maxModel' && !includesUnknown(VALID_MODELS, value)) {
+    return `Invalid model: ${String(value)}. Valid models: ${VALID_MODELS.join(', ')}`;
+  }
+  if (key === 'minModel' && value !== null && !includesUnknown(VALID_MODELS, value)) {
+    return `Invalid model: ${String(value)}. Valid models: ${VALID_MODELS.join(', ')}, null`;
+  }
+  if (key === 'logLevel' && !includesUnknown(['quiet', 'normal', 'verbose'], value)) {
+    return `Invalid log level: ${String(value)}. Valid levels: quiet, normal, verbose`;
+  }
+  if (key === 'defaultDelivery' && !includesUnknown(['none', 'pr', 'ship'], value)) {
+    return `Invalid defaultDelivery: ${String(value)}. Valid: none, pr, ship`;
+  }
+  if (key === 'defaultIsolation' && !includesUnknown(['none', 'worktree', 'docker'], value)) {
+    return `Invalid defaultIsolation: ${String(value)}. Valid: none, worktree, docker`;
+  }
+  if (key === 'claudeCommand') return validateClaudeCommand(value);
+  if (key === 'defaultProvider') {
+    const normalized = normalizeProviderName(value);
+    if (typeof normalized !== 'string' || !VALID_PROVIDERS.includes(normalized)) {
+      return `Invalid provider: ${String(value)}. Valid providers: ${VALID_PROVIDERS.join(', ')}`;
+    }
+  }
+  if (key === 'providerSettings') return validateProviderSettings(value);
+  if (key === 'dockerMounts') return validateMountConfig(value);
+  if (key === 'dockerEnvPassthrough') return validateEnvPassthrough(value);
+
+  const issueSourceError = validateIssueSourceSetting(key, value);
+  return issueSourceError === undefined ? null : issueSourceError;
+}
+
+function coerceValue(key: string, value: unknown): unknown {
+  const defaultValue = DEFAULT_SETTINGS[key];
+  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 = parseFloat(String(value));
+    if (isNaN(parsed)) throw new Error(`Invalid number: ${String(value)}`);
+    return parsed;
+  }
+  if (Array.isArray(defaultValue)) {
+    if (typeof value === 'string') {
+      try {
+        const parsed: unknown = JSON.parse(value);
+        if (!Array.isArray(parsed)) throw new Error(`${key} must be an array`);
+        return parsed;
+      } catch (error: unknown) {
+        if (error instanceof SyntaxError) {
+          throw new Error(`Invalid JSON for ${key}: ${value}`);
+        }
+        throw error;
+      }
+    }
+    return value;
+  }
+  if (key === 'providerSettings') {
+    if (typeof value === 'string') {
+      try {
+        const parsed: unknown = JSON.parse(value);
+        return normalizeProviderSettings(parsed);
+      } catch {
+        throw new Error(`Invalid JSON for providerSettings: ${value}`);
+      }
+    }
+    return normalizeProviderSettings(value);
+  }
+  if (key === 'defaultProvider') return normalizeProviderName(value);
+  return value;
+}
+
+export = { validateSetting, coerceValue };

package/src/legacy-lib/settings.ts

@@ -0,0 +1,87 @@
+interface SettingsRecord extends Record<string, unknown> {
+  claudeCommand?: string;
+}
+
+interface StorageFacade {
+  loadSettings(options?: { silent?: unknown }): SettingsRecord;
+  mutateSettings(
+    mutator: (settings: SettingsRecord) => unknown,
+    options?: { lockTimeoutMs?: number }
+  ): unknown;
+  getSettingsFile(): string;
+  settingsFileExists(): boolean;
+}
+
+interface ValidationFacade {
+  validateSetting(key: string, value: unknown): string | null;
+  coerceValue(key: string, value: unknown): unknown;
+}
+
+interface ModelsFacade {
+  MODEL_HIERARCHY: Readonly<Record<string, number>>;
+  VALID_MODELS: readonly string[];
+  validateModelAgainstMax(
+    requestedModel: string | null | undefined,
+    maxModel: string,
+    minModel?: string | null
+  ): string;
+  mapLegacyModelToLevel(model: unknown): 'level1' | 'level2' | 'level3' | null;
+}
+
+interface DefaultsFacade {
+  DEFAULT_SETTINGS: SettingsRecord;
+}
+
+interface ProviderDefaultsFacade {
+  clearProviderDefaultsCache(): void;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const storage: StorageFacade = require('./settings-storage');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const validation: ValidationFacade = require('./settings-validation');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const models: ModelsFacade = require('./settings-models');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const defaults: DefaultsFacade = require('./settings-defaults');
+// 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 { SettingsValidationError }: { SettingsValidationError: typeof Error } =
+  require('./settings-error');
+
+const { loadSettings, mutateSettings, getSettingsFile, settingsFileExists } = storage;
+const { validateSetting, coerceValue } = validation;
+const { MODEL_HIERARCHY, VALID_MODELS, validateModelAgainstMax, mapLegacyModelToLevel } = models;
+const { DEFAULT_SETTINGS } = defaults;
+const { clearProviderDefaultsCache } = providerDefaults;
+
+function getClaudeCommand(): { command: string | undefined; args: string[] } {
+  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),
+  };
+}
+
+export = {
+  loadSettings,
+  mutateSettings,
+  validateSetting,
+  coerceValue,
+  SettingsValidationError,
+  DEFAULT_SETTINGS,
+  getSettingsFile,
+  settingsFileExists,
+  getClaudeCommand,
+  MODEL_HIERARCHY,
+  VALID_MODELS,
+  validateModelAgainstMax,
+  clearProviderDefaultsCache,
+  mapLegacyModelToLevel,
+  get SETTINGS_FILE(): string {
+    return getSettingsFile();
+  },
+};

package/src/legacy-lib/setup-apply-types.ts

@@ -0,0 +1,70 @@
+export type SettingsMap = Record<string, unknown>;
+export type DecisionScope = 'global' | 'repo';
+
+export interface DecisionTarget {
+  path: string;
+  scope: DecisionScope;
+}
+
+export interface JournalEntry {
+  appliedAt: string;
+  appliedValue: unknown;
+  path: string;
+  priorValue: unknown;
+  repoRoot: string | null;
+  scope: string;
+}
+
+export interface SetupJournal {
+  entries: JournalEntry[];
+  version: number;
+}
+
+export interface ApplyDependencies {
+  VALID_PROVIDERS: readonly string[];
+  checkGhAuth(): { authenticated?: unknown } | null;
+  listIssueProviders(): string[];
+  loadSettings(): SettingsMap;
+  mutateSettings<T>(mutator: (settings: SettingsMap) => T): T;
+  now(): string;
+  readFile(filePath: string): string;
+  readRepoSettings(cwd: string): { repoRoot: string | null; settings: SettingsMap | null };
+  writeRepoSettings(repoRoot: string | null, settings: SettingsMap): unknown;
+}
+
+export interface ResolvedDecision {
+  decisionId: string;
+  inputValue: unknown;
+  target: DecisionTarget;
+  writeValue: unknown;
+}
+
+export interface DecisionResult {
+  applied: boolean;
+  decisionId: string;
+  from: unknown;
+  skippedReason?: string;
+  to: unknown;
+}
+
+export interface PendingWrite {
+  path: string;
+  priorValue: unknown;
+  scope: DecisionScope;
+  settingsObj: SettingsMap;
+  writeValue: unknown;
+}
+
+interface SharedApplyParams {
+  allowRiskyDefaults?: boolean;
+  cwd: string;
+  deps?: Partial<ApplyDependencies>;
+}
+
+export interface ApplyDecisionValuesParams extends SharedApplyParams {
+  decisions: unknown;
+}
+
+export interface ApplyDecisionsParams extends SharedApplyParams {
+  decisionsPath: string;
+}