@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/lib/settings-issue-providers.js

@@ -0,0 +1,12 @@
+"use strict";
+let issueProviderFns = null;
+function getIssueProviderFns() {
+    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 = require('../src/issue-providers');
+    issueProviderFns = loaded;
+    return loaded;
+}
+module.exports = { getIssueProviderFns };

package/lib/settings-models.d.ts

@@ -0,0 +1,22 @@
+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>;
+}
+declare function validateModelAgainstMax(requestedModel: string | null | undefined, maxModel: string, minModel?: string | null): string;
+declare function mapLegacyModelToLevel(model: unknown): ModelLevel | null;
+declare function applyLegacyModelBounds(settings: SettingsRecord): SettingsRecord;
+declare const _default: {
+    MODEL_HIERARCHY: Readonly<Record<string, number>>;
+    VALID_MODELS: string[];
+    validateModelAgainstMax: typeof validateModelAgainstMax;
+    mapLegacyModelToLevel: typeof mapLegacyModelToLevel;
+    applyLegacyModelBounds: typeof applyLegacyModelBounds;
+};
+export = _default;

package/lib/settings-models.js

@@ -0,0 +1,93 @@
+"use strict";
+const MODEL_HIERARCHY = Object.freeze({
+    opus: 3,
+    fable: 3,
+    sonnet: 2,
+    haiku: 1,
+});
+const VALID_MODELS = Object.keys(MODEL_HIERARCHY);
+const LEVEL_RANKS = Object.freeze({
+    level1: 1,
+    level2: 2,
+    level3: 3,
+});
+function validateModelAgainstMax(requestedModel, maxModel, minModel = null) {
+    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) {
+    switch (model) {
+        case 'haiku':
+            return 'level1';
+        case 'sonnet':
+            return 'level2';
+        case 'opus':
+            return 'level3';
+        default:
+            return null;
+    }
+}
+function levelRank(level, fallback) {
+    return LEVEL_RANKS[level ?? fallback];
+}
+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 = 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;
+}
+module.exports = {
+    MODEL_HIERARCHY,
+    VALID_MODELS,
+    validateModelAgainstMax,
+    mapLegacyModelToLevel,
+    applyLegacyModelBounds,
+};

package/lib/settings-storage.d.ts

@@ -0,0 +1,23 @@
+interface SettingsRecord extends Record<string, unknown> {
+    autoCheckUpdates?: unknown;
+    lastUpdateCheckClaim?: unknown;
+    updatePolicy?: unknown;
+}
+interface LoadOptions {
+    silent?: unknown;
+}
+interface MutationOptions {
+    lockTimeoutMs?: number;
+}
+type SettingsMutator = (settings: SettingsRecord) => unknown;
+declare function getSettingsFile(): string;
+declare function settingsFileExists(): boolean;
+declare function loadSettings(options?: LoadOptions): SettingsRecord;
+declare function mutateSettings(mutator: SettingsMutator, options?: MutationOptions): unknown;
+declare const _default: {
+    loadSettings: typeof loadSettings;
+    mutateSettings: typeof mutateSettings;
+    getSettingsFile: typeof getSettingsFile;
+    settingsFileExists: typeof settingsFileExists;
+};
+export = _default;

package/lib/settings-storage.js

@@ -0,0 +1,205 @@
+"use strict";
+const crypto = require("crypto");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const lockfile = require('proper-lockfile');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const defaults = require('./settings-defaults');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { SettingsValidationError } = 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) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function errorCode(error) {
+    return error !== null && typeof error === 'object' && 'code' in error ? error.code : undefined;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isPromiseLike(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        'then' in value &&
+        typeof value.then === 'function');
+}
+function getSettingsFile() {
+    return (process.env.ZEROSHOT_SETTINGS_FILE || path.join(os.homedir(), '.zeroshot', 'settings.json'));
+}
+function settingsFileExists() {
+    return fs.existsSync(getSettingsFile());
+}
+function loadSettings(options = {}) {
+    const settingsFile = getSettingsFile();
+    if (!fs.existsSync(settingsFile)) {
+        return resolvedDefaultSettings();
+    }
+    try {
+        const parsed = 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) {
+    if (!fs.existsSync(settingsFile)) {
+        return {
+            settings: resolvedDefaultSettings(),
+            requiresClaimInvalidation: false,
+            requiresRecovery: false,
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
+    }
+    catch (error) {
+        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) {
+    try {
+        return fs.statSync(settingsFile).mode & 0o600;
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT')
+            return 0o600;
+        throw error;
+    }
+}
+function atomicWriteSettings(settingsFile, settings) {
+    const dir = path.dirname(settingsFile);
+    const temporaryFile = path.join(dir, `.${path.basename(settingsFile)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+    let operationError;
+    try {
+        fs.writeFileSync(temporaryFile, JSON.stringify(settings, null, 2), {
+            encoding: 'utf8',
+            flag: 'wx',
+            mode: getAtomicSettingsMode(settingsFile),
+        });
+        fs.renameSync(temporaryFile, settingsFile);
+    }
+    catch (error) {
+        operationError = error;
+    }
+    try {
+        fs.unlinkSync(temporaryFile);
+    }
+    catch (error) {
+        if (errorCode(error) !== 'ENOENT' && !operationError)
+            operationError = error;
+    }
+    if (operationError)
+        throw operationError;
+}
+function acquireSettingsLock(settingsFile, lockfilePath, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    return tryAcquireSettingsLock(settingsFile, lockfilePath, deadline);
+}
+function shouldRetrySettingsLock(error, deadline) {
+    return errorCode(error) === 'ELOCKED' && Date.now() < deadline;
+}
+function tryAcquireSettingsLock(settingsFile, lockfilePath, deadline) {
+    try {
+        return lockfile.lockSync(settingsFile, {
+            lockfilePath,
+            realpath: false,
+            stale: SETTINGS_LOCK_STALE_MS,
+        });
+    }
+    catch (error) {
+        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, mutator) {
+    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) {
+    return error instanceof SettingsValidationError
+        ? error
+        : new Error(`Unable to persist global settings: ${errorMessage(error)}`, { cause: error });
+}
+function releaseSettingsLock(release, mutationError) {
+    if (!release)
+        return mutationError;
+    try {
+        release();
+        return mutationError;
+    }
+    catch (error) {
+        return (mutationError ||
+            new Error(`Unable to release global settings lock: ${errorMessage(error)}`, { cause: error }));
+    }
+}
+function mutateSettings(mutator, options = {}) {
+    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;
+    let result;
+    let mutationError;
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        release = acquireSettingsLock(settingsFile, lockfilePath, options.lockTimeoutMs ?? SETTINGS_LOCK_TIMEOUT_MS);
+        result = applySettingsMutation(settingsFile, mutator);
+    }
+    catch (error) {
+        mutationError = asMutationError(error);
+    }
+    finally {
+        mutationError = releaseSettingsLock(release, mutationError);
+    }
+    if (mutationError)
+        throw mutationError;
+    return result;
+}
+module.exports = { loadSettings, mutateSettings, getSettingsFile, settingsFileExists };

package/lib/settings-validation.d.ts

@@ -0,0 +1,7 @@
+declare function validateSetting(key: string, value: unknown): string | null;
+declare function coerceValue(key: string, value: unknown): unknown;
+declare const _default: {
+    validateSetting: typeof validateSetting;
+    coerceValue: typeof coerceValue;
+};
+export = _default;

package/lib/settings-validation.js

@@ -0,0 +1,182 @@
+"use strict";
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const dockerConfig = require('./docker-config');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const providerNames = require('./provider-names');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const defaults = require('./settings-defaults');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const models = require('./settings-models');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const issueProviders = 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) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function includesUnknown(values, value) {
+    return values.includes(value);
+}
+function validateClaudeCommand(value) {
+    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) {
+    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 = 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) {
+            const message = error instanceof Error ? error.message : String(error);
+            return `Failed to validate ${providerName} settings: ${message}`;
+        }
+    }
+    return null;
+}
+function validateIssueSourceSetting(key, value) {
+    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, value) {
+    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, value) {
+    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, value) {
+    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 = JSON.parse(value);
+                if (!Array.isArray(parsed))
+                    throw new Error(`${key} must be an array`);
+                return parsed;
+            }
+            catch (error) {
+                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 = 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;
+}
+module.exports = { validateSetting, coerceValue };

package/lib/settings.d.ts

@@ -0,0 +1,29 @@
+interface SettingsRecord extends Record<string, unknown> {
+    claudeCommand?: string;
+}
+declare function getClaudeCommand(): {
+    command: string | undefined;
+    args: string[];
+};
+declare const _default: {
+    loadSettings: (options?: {
+        silent?: unknown;
+    }) => SettingsRecord;
+    mutateSettings: (mutator: (settings: SettingsRecord) => unknown, options?: {
+        lockTimeoutMs?: number;
+    }) => unknown;
+    validateSetting: (key: string, value: unknown) => string | null;
+    coerceValue: (key: string, value: unknown) => unknown;
+    SettingsValidationError: ErrorConstructor;
+    DEFAULT_SETTINGS: SettingsRecord;
+    getSettingsFile: () => string;
+    settingsFileExists: () => boolean;
+    getClaudeCommand: typeof getClaudeCommand;
+    MODEL_HIERARCHY: Readonly<Record<string, number>>;
+    VALID_MODELS: readonly string[];
+    validateModelAgainstMax: (requestedModel: string | null | undefined, maxModel: string, minModel?: string | null) => string;
+    clearProviderDefaultsCache: () => void;
+    mapLegacyModelToLevel: (model: unknown) => "level1" | "level2" | "level3" | null;
+    readonly SETTINGS_FILE: string;
+};
+export = _default;