sneakoscope 6.0.3 → 6.1.2

package/dist/core/codex-exec-output-schema.js

@@ -3,6 +3,7 @@ import fsp from 'node:fs/promises';
 import { ensureDir, exists, packageRoot, readJson, runProcess, which } from './fsx.js';
 import { codexVersionPolicy, compareSemverLike, parseCodexVersionText } from './codex-compat/codex-version-policy.js';
 import { validateJsonSchemaRecursive } from './json-schema-validator.js';
+import { inspectCodexLbCliLaunchRecovery } from './codex-control/codex-lb-launch-recovery.js';
 export async function detectCodexExecOutputSchemaSyntax(opts = {}) {
     const codexBin = opts.codexBin || await which('codex').catch(() => null);
     if (!codexBin) {
@@ -167,6 +168,33 @@ export async function buildCodexExecResumeOutputSchemaArgs(input) {
     return args;
 }
 export async function runCodexExecResumeWithOutputSchema(input, opts = {}) {
+    const root = opts.cwd || packageRoot();
+    const env = opts.env || process.env;
+    const toolOutputRecovery = await inspectCodexLbCliLaunchRecovery({
+        root,
+        env,
+        cliArgs: input.extraArgs || [],
+        ...(opts.recoveryFetch ? { fetchImpl: opts.recoveryFetch } : {}),
+        ...(opts.recoveryTimeoutMs === undefined ? {} : { timeoutMs: opts.recoveryTimeoutMs })
+    });
+    if (!toolOutputRecovery.ok) {
+        return {
+            schema: 'sks.codex-exec-output-schema-run.v1',
+            ok: false,
+            status: 'blocked',
+            args: [],
+            codex_bin: opts.codexBin || null,
+            output_file: null,
+            parsed_json: null,
+            blocker: structuredOutputBlocker('codex_lb_tool_output_recovery_blocked', toolOutputRecovery.blockers.join(', ')),
+            validation: { ok: false, issues: ['codex_lb_tool_output_recovery_blocked'] },
+            stdout_tail: '',
+            stderr_tail: '',
+            timed_out: false,
+            exit_code: null,
+            codex_lb_tool_output_recovery: toolOutputRecovery
+        };
+    }
     const availability = await detectCodexExecResumeOutputSchema({ codexBin: opts.codexBin || undefined });
     if (!availability.codex_bin || availability.status !== 'available' || !availability.output_schema_supported) {
         const status = availability.status === 'available' ? 'degraded_supported' : availability.status;
@@ -183,7 +211,8 @@ export async function runCodexExecResumeWithOutputSchema(input, opts = {}) {
             stdout_tail: '',
             stderr_tail: '',
             timed_out: false,
-            exit_code: null
+            exit_code: null,
+            codex_lb_tool_output_recovery: toolOutputRecovery
         };
     }
     const outputFile = input.outputFile
@@ -192,13 +221,12 @@ export async function runCodexExecResumeWithOutputSchema(input, opts = {}) {
     await ensureDir(path.dirname(outputFile));
     const args = await buildCodexExecResumeOutputSchemaArgs({ ...input, outputFile });
     const runOpts = {
-        cwd: opts.cwd || packageRoot(),
+        cwd: root,
         timeoutMs: opts.timeoutMs || 120_000,
         maxOutputBytes: opts.maxOutputBytes || 256 * 1024
     };
-    if (opts.env)
-        runOpts.env = opts.env;
-    const result = await runProcess(availability.codex_bin, args, runOpts);
+    runOpts.env = env;
+    const result = await (opts.runProcessImpl || runProcess)(availability.codex_bin, args, runOpts);
     const outputText = await readOutputText(outputFile, result.stdout);
     const parsed = parseStructuredCodexOutput(outputText);
     const schema = await readJson(path.resolve(input.outputSchemaPath), null);
@@ -221,7 +249,8 @@ export async function runCodexExecResumeWithOutputSchema(input, opts = {}) {
         stdout_tail: redactCodexOutput(result.stdout).slice(-12_000),
         stderr_tail: redactCodexOutput(result.stderr).slice(-12_000),
         timed_out: result.timedOut,
-        exit_code: result.code
+        exit_code: result.code,
+        codex_lb_tool_output_recovery: toolOutputRecovery
     };
 }
 export function parseStructuredCodexOutput(text) {

package/dist/core/codex-lb/codex-lb-env.js

@@ -42,6 +42,18 @@ export async function readCodexLbModelCatalog(opts = {}) {
             blockers: loaded.missing.length ? loaded.missing.map((item) => `codex_lb_missing:${item}`) : ['codex_lb_not_configured']
         };
     }
+    const transportBlocker = codexLbBaseUrlSecurityBlocker(loaded.base_url);
+    if (transportBlocker) {
+        return {
+            schema: 'sks.codex-lb-model-catalog.v1',
+            ok: false,
+            status: 'blocked',
+            models: [],
+            model_efforts: {},
+            http_status: null,
+            blockers: [transportBlocker]
+        };
+    }
     const fetchImpl = opts.fetchImpl || fetch;
     try {
         const response = await fetchImpl(`${loaded.base_url}/models`, {
@@ -116,6 +128,23 @@ export function normalizeCodexLbBaseUrl(input = '') {
     host = host.replace(/\/+$/, '');
     return /\/backend-api\/codex$/i.test(host) ? host : `${host}/backend-api/codex`;
 }
+export function codexLbBaseUrlSecurityBlocker(input) {
+    try {
+        const url = new URL(String(input || ''));
+        if (url.username || url.password)
+            return 'codex_lb_base_url_userinfo_forbidden';
+        if (url.protocol === 'https:')
+            return null;
+        const host = url.hostname.toLowerCase();
+        const loopback = host === 'localhost' || host === '::1' || host === '[::1]' || /^127(?:\.\d{1,3}){3}$/.test(host);
+        if (url.protocol === 'http:' && loopback)
+            return null;
+        return 'codex_lb_insecure_base_url';
+    }
+    catch {
+        return 'codex_lb_invalid_base_url';
+    }
+}
 export async function loadCodexLbEnv(opts = {}) {
     const home = opts.home || process.env.HOME || os.homedir();
     const envPaths = [
@@ -125,7 +154,7 @@ export async function loadCodexLbEnv(opts = {}) {
     const sourcePriority = ['process.env', 'keychain', 'env-file', 'legacy-env-file'];
     if (opts.allowProjectSecrets)
         sourcePriority.push('project-local');
-    const processEnv = pickEnv(process.env);
+    const processEnv = pickEnv(opts.processEnv || process.env);
     const envFile = await readEnvFile(envPaths[0]);
     const legacyEnv = await readEnvFile(envPaths[1]);
     const keychain = await readMacKeychain(opts);

package/dist/core/codex-lb/codex-lb-tool-catalog.js

@@ -0,0 +1,478 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ensureDir, exists, nowIso, sha256, writeTextAtomic } from '../fsx.js';
+import { codexLbBaseUrlSecurityBlocker, normalizeCodexLbBaseUrl } from './codex-lb-env.js';
+export const CODEX_LB_TOOL_CATALOG_FILENAME = 'sks-codex-lb-tool-catalog.json';
+export const CODEX_LB_TOOL_CATALOG_SCHEMA = 'sks.codex-lb-tool-catalog.v1';
+export const CODEX_LB_TOOL_CATALOG_METADATA_SCHEMA = 'sks.codex-lb-tool-catalog-metadata.v1';
+export const CODEX_LB_TOOL_CATALOG_MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
+export const CODEX_LB_TOOL_CATALOG_MAX_MODELS = 128;
+const CODEX_LB_TOOL_CATALOG_MAX_METADATA_BYTES = 16 * 1024;
+const DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const GPT56_MODEL_RE = /^gpt-5\.6-(?:sol|terra|luna)$/;
+const ensureInflight = new Map();
+const REQUIRED_CODEX_0144_MODEL_FIELDS = {
+    slug: ['string'],
+    display_name: ['string'],
+    supported_reasoning_levels: ['array'],
+    shell_type: ['string'],
+    visibility: ['string'],
+    supported_in_api: ['boolean'],
+    priority: ['number'],
+    base_instructions: ['string'],
+    supports_reasoning_summaries: ['boolean'],
+    support_verbosity: ['boolean'],
+    truncation_policy: ['object'],
+    supports_parallel_tool_calls: ['boolean'],
+    experimental_supported_tools: ['array']
+};
+// Exact union observed in Codex CLI 0.144.1's native cache and codex-lb catalog.
+// Unknown response fields are deliberately not persisted into a Codex-owned file.
+const CODEX_0144_MODEL_FIELD_TYPES = {
+    ...REQUIRED_CODEX_0144_MODEL_FIELDS,
+    description: ['string'],
+    default_reasoning_level: ['string'],
+    additional_speed_tiers: ['array'],
+    service_tiers: ['array'],
+    availability_nux: ['object', 'null'],
+    upgrade: ['object', 'null'],
+    model_messages: ['object'],
+    include_skills_usage_instructions: ['boolean'],
+    default_reasoning_summary: ['string'],
+    default_verbosity: ['string'],
+    apply_patch_tool_type: ['string'],
+    web_search_tool_type: ['string'],
+    supports_image_detail_original: ['boolean'],
+    context_window: ['number'],
+    max_context_window: ['number'],
+    comp_hash: ['string'],
+    effective_context_window_percent: ['number'],
+    input_modalities: ['array'],
+    supports_search_tool: ['boolean'],
+    use_responses_lite: ['boolean'],
+    tool_mode: ['string', 'null'],
+    multi_agent_version: ['string', 'null'],
+    minimal_client_version: ['string'],
+    available_in_plans: ['array'],
+    prefer_websockets: ['boolean'],
+    auto_review_model_override: ['string', 'null'],
+    auto_compact_token_limit: ['number', 'null'],
+    reasoning_summary_format: ['string'],
+    default_service_tier: ['string', 'null']
+};
+export function isCodexLbGpt56Model(model) {
+    return GPT56_MODEL_RE.test(String(model || '').trim());
+}
+export function codexLbToolCatalogPath(codexHome) {
+    return path.join(path.resolve(codexHome), CODEX_LB_TOOL_CATALOG_FILENAME);
+}
+export function codexLbToolCatalogMetadataPath(catalogPath) {
+    return `${path.resolve(catalogPath)}.meta.json`;
+}
+export function normalizeCodexLbToolCatalog(payload, opts = {}) {
+    const rows = Array.isArray(payload?.models)
+        ? payload.models
+        : Array.isArray(payload?.data)
+            ? payload.data
+            : [];
+    const maxModels = boundedPositiveInt(opts.maxModels, CODEX_LB_TOOL_CATALOG_MAX_MODELS);
+    const limitedRows = rows.slice(0, maxModels);
+    const patchedModels = [];
+    const gpt56Models = [];
+    const validationIssues = [];
+    const models = limitedRows.map((row, index) => {
+        if (!isPlainObject(row)) {
+            validationIssues.push(`codex_lb_model_catalog_row_invalid:${index}:object`);
+            return {};
+        }
+        const model = String(row.slug || row.id || row.model || row.name || '').trim();
+        if (isCodexLbGpt56Model(model))
+            gpt56Models.push(model);
+        const sanitized = sanitizeCodex0144Model(row);
+        validationIssues.push(...validateCodex0144Model(sanitized, index));
+        if (!isCodexLbGpt56Model(model))
+            return sanitized;
+        if (row.use_responses_lite !== false)
+            patchedModels.push(model);
+        // Codex 0.144.1 omits the request's `tools` field for Responses Lite.
+        // Preserve the provider's tool_mode contract, but force full Responses.
+        return { ...sanitized, use_responses_lite: false };
+    });
+    const compatibleRows = models.filter((row) => isCodexLbGpt56Model(row.slug));
+    const compatible = gpt56Models.length > 0
+        && compatibleRows.length === gpt56Models.length
+        && compatibleRows.every((row) => row.use_responses_lite === false);
+    const blockers = uniqueBounded([
+        ...(rows.length ? [] : ['codex_lb_model_catalog_empty']),
+        ...(rows.length > maxModels ? [`codex_lb_model_catalog_model_limit_exceeded:${rows.length}:${maxModels}`] : []),
+        ...validationIssues,
+        ...(gpt56Models.length ? [] : ['codex_lb_gpt56_models_missing']),
+        ...(compatible ? [] : ['codex_lb_gpt56_tools_transport_incompatible'])
+    ]);
+    return {
+        schema: CODEX_LB_TOOL_CATALOG_SCHEMA,
+        ok: blockers.length === 0,
+        catalog: { models },
+        model_count: models.length,
+        gpt56_models: [...new Set(gpt56Models)].sort(),
+        patched_models: [...new Set(patchedModels)].sort(),
+        tools_transport: compatible ? 'full_responses' : 'unverified',
+        blockers
+    };
+}
+export async function inspectCodexLbToolCatalog(file, opts = {}) {
+    const maxBytes = boundedPositiveInt(opts.maxBytes, CODEX_LB_TOOL_CATALOG_MAX_RESPONSE_BYTES);
+    const fileSafety = await inspectSecureRegularFile(file, maxBytes, 'codex_lb_tool_catalog');
+    if (!fileSafety.ok)
+        return incompatibleInspection(file, fileSafety, fileSafety.blockers);
+    let text = '';
+    let payload = null;
+    try {
+        text = await fs.readFile(file, 'utf8');
+        payload = JSON.parse(text);
+    }
+    catch {
+        return incompatibleInspection(file, fileSafety, ['codex_lb_tool_catalog_json_invalid']);
+    }
+    const normalized = normalizeCodexLbToolCatalog(payload, opts.maxModels === undefined ? {} : { maxModels: opts.maxModels });
+    const { catalog: _catalog, ...status } = normalized;
+    const metadataPath = codexLbToolCatalogMetadataPath(file);
+    const identityBlockers = [];
+    let identityVerified = false;
+    let cacheOrigin = null;
+    if (opts.expectedIdentity) {
+        const metadataSafety = await inspectSecureRegularFile(metadataPath, CODEX_LB_TOOL_CATALOG_MAX_METADATA_BYTES, 'codex_lb_tool_catalog_metadata');
+        if (!metadataSafety.ok) {
+            identityBlockers.push(...metadataSafety.blockers);
+        }
+        else {
+            try {
+                const metadata = JSON.parse(await fs.readFile(metadataPath, 'utf8'));
+                cacheOrigin = typeof metadata?.identity?.origin === 'string' ? metadata.identity.origin : null;
+                if (metadata?.schema !== CODEX_LB_TOOL_CATALOG_METADATA_SCHEMA)
+                    identityBlockers.push('codex_lb_tool_catalog_metadata_schema_invalid');
+                if (metadata?.catalog_sha256 !== sha256(text))
+                    identityBlockers.push('codex_lb_tool_catalog_metadata_hash_mismatch');
+                if (!sameCatalogIdentity(metadata?.identity, opts.expectedIdentity))
+                    identityBlockers.push('codex_lb_tool_catalog_identity_mismatch');
+                identityVerified = identityBlockers.length === 0;
+            }
+            catch {
+                identityBlockers.push('codex_lb_tool_catalog_metadata_json_invalid');
+            }
+        }
+    }
+    const blockers = uniqueBounded([...normalized.blockers, ...identityBlockers]);
+    return {
+        ...status,
+        ok: blockers.length === 0,
+        path: file,
+        exists: true,
+        updated_at_ms: fileSafety.updated_at_ms,
+        size_bytes: fileSafety.size_bytes,
+        mode: fileSafety.mode,
+        owner_uid: fileSafety.owner_uid,
+        metadata_path: metadataPath,
+        identity_verified: opts.expectedIdentity ? identityVerified : null,
+        cache_origin: cacheOrigin,
+        blockers
+    };
+}
+export async function ensureCodexLbToolCatalog(input) {
+    const outputPath = path.resolve(input.outputPath || codexLbToolCatalogPath(input.codexHome));
+    const baseUrl = normalizeCodexLbBaseUrl(input.baseUrl);
+    const apiKey = String(input.apiKey || '').trim();
+    const transportBlocker = catalogTransportBlocker(baseUrl);
+    if (transportBlocker || !apiKey) {
+        return blockedResult(outputPath, [transportBlocker || 'codex_lb_api_key_missing']);
+    }
+    const identity = catalogIdentity(baseUrl, apiKey);
+    const inflightKey = [
+        outputPath,
+        identity.base_url_sha256,
+        identity.api_key_sha256,
+        input.force === true ? 'force' : 'normal',
+        boundedPositiveInt(input.maxResponseBytes, CODEX_LB_TOOL_CATALOG_MAX_RESPONSE_BYTES),
+        boundedPositiveInt(input.maxModels, CODEX_LB_TOOL_CATALOG_MAX_MODELS)
+    ].join(':');
+    const existing = ensureInflight.get(inflightKey);
+    if (existing)
+        return existing;
+    const promise = ensureValidatedCodexLbToolCatalog(input, outputPath, baseUrl, apiKey, identity)
+        .finally(() => ensureInflight.delete(inflightKey));
+    ensureInflight.set(inflightKey, promise);
+    return promise;
+}
+async function ensureValidatedCodexLbToolCatalog(input, outputPath, baseUrl, apiKey, identity) {
+    const now = input.now ? input.now() : Date.now();
+    const maxAgeMs = Math.max(0, Number(input.maxAgeMs ?? DEFAULT_MAX_AGE_MS));
+    const inspectOpts = {
+        expectedIdentity: identity,
+        ...(input.maxResponseBytes === undefined ? {} : { maxBytes: input.maxResponseBytes }),
+        ...(input.maxModels === undefined ? {} : { maxModels: input.maxModels })
+    };
+    const cached = await inspectCodexLbToolCatalog(outputPath, inspectOpts);
+    if (!input.force && cached.ok && cacheIsFresh(cached.updated_at_ms, now, maxAgeMs)) {
+        return { ...cached, generated_at: nowIso(), status: 'cached_compatible', fetched: false, required: true };
+    }
+    try {
+        const response = await (input.fetchImpl || fetch)(`${baseUrl}/models`, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(Math.max(250, Number(input.timeoutMs || 5000)))
+        });
+        if (!response.ok)
+            throw new CatalogFetchError(`codex_lb_models_http_${response.status}`);
+        const payload = await readJsonResponseBounded(response, boundedPositiveInt(input.maxResponseBytes, CODEX_LB_TOOL_CATALOG_MAX_RESPONSE_BYTES));
+        const normalized = normalizeCodexLbToolCatalog(payload, input.maxModels === undefined ? {} : { maxModels: input.maxModels });
+        if (!normalized.ok) {
+            const fallback = await inspectCodexLbToolCatalog(outputPath, inspectOpts);
+            if (fallback.ok) {
+                return { ...fallback, generated_at: nowIso(), status: 'cached_compatible_after_refresh_rejected', fetched: true, required: true, refresh_blockers: normalized.blockers };
+            }
+            const { catalog: _catalog, ...status } = normalized;
+            return { ...status, generated_at: nowIso(), status: 'blocked', path: outputPath, exists: await exists(outputPath), fetched: true, required: true };
+        }
+        await writeSecureCatalog(outputPath, normalized.catalog, identity);
+        const verified = await inspectCodexLbToolCatalog(outputPath, inspectOpts);
+        return {
+            ...verified,
+            generated_at: nowIso(),
+            status: verified.ok ? 'repaired' : 'write_verification_failed',
+            fetched: true,
+            required: true,
+            patched_models: normalized.patched_models,
+            blockers: verified.ok ? [] : verified.blockers
+        };
+    }
+    catch (error) {
+        const fallback = await inspectCodexLbToolCatalog(outputPath, inspectOpts);
+        if (fallback.ok) {
+            return {
+                ...fallback,
+                generated_at: nowIso(),
+                status: 'cached_compatible_after_refresh_failed',
+                fetched: false,
+                required: true,
+                refresh_error: safeError(error, [apiKey])
+            };
+        }
+        const code = error instanceof CatalogFetchError ? error.code : 'codex_lb_tool_catalog_fetch_failed';
+        return {
+            ...blockedResult(outputPath, uniqueBounded(['codex_lb_tool_catalog_fetch_failed', code])),
+            status: 'fetch_failed',
+            fetched: false,
+            error: safeError(error, [apiKey])
+        };
+    }
+}
+async function readJsonResponseBounded(response, maxBytes) {
+    const advertised = Number(response.headers.get('content-length'));
+    if (Number.isFinite(advertised) && advertised > maxBytes)
+        throw new CatalogFetchError('codex_lb_tool_catalog_response_too_large');
+    if (!response.body) {
+        const text = await response.text();
+        if (Buffer.byteLength(text, 'utf8') > maxBytes)
+            throw new CatalogFetchError('codex_lb_tool_catalog_response_too_large');
+        return parseCatalogJson(text);
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!value)
+                continue;
+            total += value.byteLength;
+            if (total > maxBytes) {
+                await reader.cancel().catch(() => undefined);
+                throw new CatalogFetchError('codex_lb_tool_catalog_response_too_large');
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)), total);
+    return parseCatalogJson(bytes.toString('utf8'));
+}
+function parseCatalogJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new CatalogFetchError('codex_lb_tool_catalog_response_json_invalid');
+    }
+}
+async function writeSecureCatalog(file, catalog, identity) {
+    const text = `${JSON.stringify(catalog, null, 2)}\n`;
+    const metadataPath = codexLbToolCatalogMetadataPath(file);
+    const metadata = {
+        schema: CODEX_LB_TOOL_CATALOG_METADATA_SCHEMA,
+        generated_at: nowIso(),
+        catalog_schema: CODEX_LB_TOOL_CATALOG_SCHEMA,
+        catalog_sha256: sha256(text),
+        identity,
+        model_count: Array.isArray(catalog?.models) ? catalog.models.length : 0
+    };
+    await ensureDir(path.dirname(file));
+    await writeTextAtomic(file, text, { mode: 0o600 });
+    const catalogSafety = await inspectSecureRegularFile(file, CODEX_LB_TOOL_CATALOG_MAX_RESPONSE_BYTES, 'codex_lb_tool_catalog');
+    if (!catalogSafety.ok)
+        throw new CatalogFetchError(catalogSafety.blockers[0] || 'codex_lb_tool_catalog_file_insecure');
+    await writeTextAtomic(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`, { mode: 0o600 });
+    const metadataSafety = await inspectSecureRegularFile(metadataPath, CODEX_LB_TOOL_CATALOG_MAX_METADATA_BYTES, 'codex_lb_tool_catalog_metadata');
+    if (!metadataSafety.ok)
+        throw new CatalogFetchError(metadataSafety.blockers[0] || 'codex_lb_tool_catalog_metadata_file_insecure');
+}
+async function inspectSecureRegularFile(file, maxBytes, prefix) {
+    const stat = await fs.lstat(file).catch(() => null);
+    if (!stat)
+        return { ok: false, exists: false, updated_at_ms: null, size_bytes: 0, mode: null, owner_uid: null, blockers: [`${prefix}_missing`] };
+    const blockers = [];
+    if (!stat.isFile() || stat.isSymbolicLink())
+        blockers.push(`${prefix}_not_regular_file`);
+    if (stat.size > maxBytes)
+        blockers.push(`${prefix}_too_large:${stat.size}:${maxBytes}`);
+    const ownerUid = Number.isFinite(Number(stat.uid)) ? Number(stat.uid) : null;
+    const expectedUid = typeof process.getuid === 'function' ? process.getuid() : null;
+    if (expectedUid !== null && ownerUid !== expectedUid)
+        blockers.push(`${prefix}_owner_mismatch`);
+    const mode = stat.mode & 0o777;
+    if (process.platform !== 'win32' && mode !== 0o600)
+        blockers.push(`${prefix}_mode_insecure:${mode.toString(8)}`);
+    return { ok: blockers.length === 0, exists: true, updated_at_ms: stat.mtimeMs, size_bytes: stat.size, mode: mode.toString(8).padStart(3, '0'), owner_uid: ownerUid, blockers };
+}
+function sanitizeCodex0144Model(row) {
+    return Object.fromEntries(Object.keys(CODEX_0144_MODEL_FIELD_TYPES)
+        .filter((field) => Object.prototype.hasOwnProperty.call(row, field))
+        .map((field) => [field, row[field]]));
+}
+function validateCodex0144Model(row, index) {
+    const issues = [];
+    for (const [field, allowedTypes] of Object.entries(REQUIRED_CODEX_0144_MODEL_FIELDS)) {
+        if (!Object.prototype.hasOwnProperty.call(row, field)) {
+            issues.push(`codex_lb_model_catalog_required_field_missing:${index}:${field}`);
+            continue;
+        }
+        if (!allowedTypes.includes(valueType(row[field])))
+            issues.push(`codex_lb_model_catalog_field_type_invalid:${index}:${field}`);
+    }
+    for (const [field, value] of Object.entries(row)) {
+        if (!(CODEX_0144_MODEL_FIELD_TYPES[field] || []).includes(valueType(value)))
+            issues.push(`codex_lb_model_catalog_field_type_invalid:${index}:${field}`);
+    }
+    if (typeof row.slug === 'string' && !row.slug.trim())
+        issues.push(`codex_lb_model_catalog_field_empty:${index}:slug`);
+    if (typeof row.display_name === 'string' && !row.display_name.trim())
+        issues.push(`codex_lb_model_catalog_field_empty:${index}:display_name`);
+    if (Array.isArray(row.supported_reasoning_levels) && row.supported_reasoning_levels.some((entry) => !isPlainObject(entry) || typeof entry.effort !== 'string' || !entry.effort.trim())) {
+        issues.push(`codex_lb_model_catalog_reasoning_level_invalid:${index}`);
+    }
+    return issues;
+}
+function catalogTransportBlocker(baseUrl) {
+    const blocker = codexLbBaseUrlSecurityBlocker(baseUrl);
+    if (blocker)
+        return blocker;
+    try {
+        const url = new URL(baseUrl);
+        if (url.search || url.hash)
+            return 'codex_lb_base_url_query_or_fragment_forbidden';
+        return null;
+    }
+    catch {
+        return 'codex_lb_invalid_base_url';
+    }
+}
+function catalogIdentity(baseUrl, apiKey) {
+    return {
+        origin: new URL(baseUrl).origin,
+        base_url_sha256: sha256(baseUrl),
+        api_key_sha256: sha256(apiKey),
+        contract: 'codex-cli-0.144.1-model-catalog'
+    };
+}
+function sameCatalogIdentity(actual, expected) {
+    return actual?.origin === expected.origin
+        && actual?.base_url_sha256 === expected.base_url_sha256
+        && actual?.api_key_sha256 === expected.api_key_sha256
+        && actual?.contract === expected.contract;
+}
+function blockedResult(outputPath, blockers) {
+    return {
+        schema: CODEX_LB_TOOL_CATALOG_SCHEMA,
+        generated_at: nowIso(),
+        ok: false,
+        status: 'blocked',
+        path: outputPath,
+        exists: false,
+        fetched: false,
+        required: true,
+        model_count: 0,
+        gpt56_models: [],
+        patched_models: [],
+        tools_transport: 'unverified',
+        blockers: uniqueBounded(blockers)
+    };
+}
+function incompatibleInspection(file, safety, blockers) {
+    return {
+        schema: CODEX_LB_TOOL_CATALOG_SCHEMA,
+        ok: false,
+        path: file,
+        exists: safety.exists === true,
+        updated_at_ms: safety.updated_at_ms || null,
+        size_bytes: safety.size_bytes || 0,
+        mode: safety.mode || null,
+        owner_uid: safety.owner_uid ?? null,
+        metadata_path: codexLbToolCatalogMetadataPath(file),
+        identity_verified: false,
+        cache_origin: null,
+        model_count: 0,
+        gpt56_models: [],
+        patched_models: [],
+        tools_transport: 'unverified',
+        blockers: uniqueBounded(blockers)
+    };
+}
+function cacheIsFresh(updatedAtMs, now, maxAgeMs) {
+    const updated = Number(updatedAtMs);
+    const age = now - updated;
+    return Number.isFinite(updated) && Number.isFinite(age) && age >= 0 && age <= maxAgeMs;
+}
+function boundedPositiveInt(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.max(1, Math.floor(parsed)) : fallback;
+}
+function valueType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value === 'object' ? 'object' : typeof value;
+}
+function isPlainObject(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function uniqueBounded(values) {
+    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))].slice(0, 64);
+}
+function safeError(error, secrets = []) {
+    let text = String(error instanceof Error ? error.message : error || 'unknown');
+    for (const secret of secrets.filter((value) => value.length >= 4))
+        text = text.split(secret).join('<redacted>');
+    return text.replace(/(?:sk|key|token|secret)[-_a-z0-9]*/gi, '<redacted>').slice(0, 300);
+}
+class CatalogFetchError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'CatalogFetchError';
+    }
+}
+//# sourceMappingURL=codex-lb-tool-catalog.js.map