sneakoscope 4.7.1 → 4.7.3

package/dist/commands/codex-lb.js

@@ -1,12 +1,13 @@
 import path from 'node:path';
 import readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
-import { projectRoot, readStdin } from '../core/fsx.js';
+import { projectRoot, readStdin, readText } from '../core/fsx.js';
 import { flag, readOption } from '../cli/args.js';
 import { printJson } from '../cli/output.js';
 import { codexLbMetrics, readCodexLbCircuit, recordCodexLbHealthEvent, resetCodexLbCircuit, codexLbProofEvidence } from '../core/codex-lb-circuit.js';
 import { checkCodexLbResponseChain, codexLbStatus, configureCodexLb, formatCodexLbStatusText, releaseCodexLbAuthHold, repairCodexLbAuth, unselectCodexLbProvider } from '../cli/install-helpers.js';
 import { buildCodexLbSetupPlan, codexLbPersistenceSummary, renderCodexLbSetupPlan } from '../core/codex-lb/codex-lb-setup.js';
+import { restartCodexApp } from '../core/codex-app/codex-app-restart.js';
 export async function run(command, args = []) {
     const root = await projectRoot();
     const action = args[0] || 'status';
@@ -41,7 +42,7 @@ export async function run(command, args = []) {
     if (action === 'health' || action === 'verify-chain' || action === 'chain') {
         const status = await codexLbStatus();
         const blocker = !status.env_key_configured ? 'missing_env_key' : !status.base_url ? 'missing_base_url' : 'not_configured';
-        const result = status.ok ? await checkCodexLbResponseChain(status, { force: true, root }) : { ok: false, status: blocker, codex_lb: status };
+        const result = status.ok ? await checkCodexLbResponseChain(status, { force: true, root, fastMode: flag(args, '--fast') || flag(args, '--priority') }) : { ok: false, status: blocker, codex_lb: status };
         if (flag(args, '--json'))
             return printJson(result);
         console.log(`codex-lb response chain: ${result.ok ? 'ok' : `failed (${result.status})`}`);
@@ -49,6 +50,47 @@ export async function run(command, args = []) {
             process.exitCode = 1;
         return;
     }
+    if (action === 'fast-check' || action === 'fast' || action === 'verify-fast') {
+        const status = await codexLbStatus();
+        const blocker = !status.env_key_configured ? 'missing_env_key' : !status.base_url ? 'missing_base_url' : !status.provider_contract_ok ? 'provider_contract_drift' : 'not_configured';
+        const chain = status.env_key_configured && status.base_url
+            ? await checkCodexLbResponseChain(status, { force: true, cache: false, root, fastMode: true })
+            : { ok: false, status: blocker, codex_lb: status };
+        const evidence = await fastEvidenceFromChain(chain, readOption(args, '--request-log', readOption(args, '--request-log-json', null)));
+        const providerReady = status.provider_contract_ok === true;
+        const result = {
+            schema: 'sks.codex-lb-fast-check.v1',
+            ok: Boolean(providerReady && chain.ok && evidence.fast_requested && evidence.fast_actual),
+            status: !providerReady
+                ? 'provider_contract_drift'
+                : chain.ok
+                    ? evidence.fast_actual
+                        ? 'fast_verified'
+                        : evidence.fast_requested
+                            ? 'fast_requested_but_actual_unverified'
+                            : 'fast_not_requested'
+                    : chain.status,
+            codex_lb: status,
+            chain,
+            evidence,
+            blockers: [
+                ...(providerReady ? [] : ['codex_lb_provider_contract_drift']),
+                ...(chain.ok
+                    ? evidence.fast_actual
+                        ? []
+                        : ['codex_lb_actual_fast_service_tier_unverified']
+                    : [chain.status || blocker])
+            ]
+        };
+        if (flag(args, '--json'))
+            return printJson(result);
+        console.log(`codex-lb fast check: ${result.ok ? 'ok' : `blocked (${result.status})`}`);
+        if (!result.ok) {
+            console.log('Need codex-lb request evidence: requestedServiceTier=priority and actualServiceTier/serviceTier=priority.');
+            process.exitCode = 1;
+        }
+        return;
+    }
     if (action === 'repair' || action === 'resync' || action === 'login') {
         const result = await repairCodexLbAuth();
         if (flag(args, '--json'))
@@ -97,20 +139,27 @@ export async function run(command, args = []) {
             process.exitCode = 1;
             return;
         }
-        const result = await configureCodexLb({ host, apiKey: newKey });
+        const result = await configureCodexLb({ host, apiKey: newKey, authMode: flag(args, '--preserve-auth') ? 'preserve' : 'codex-lb', forceCodexLbApiKeyAuth: !flag(args, '--preserve-auth') });
+        const restart = await maybeRestartCodexAppForAuthSwitch(args, Boolean(result.ok));
+        const output = { ...result, action: 'set-key', restart_app: restart };
         if (flag(args, '--json'))
-            return printJson({ ...result, action: 'set-key' });
+            return printJson(output);
         console.log(result.ok ? `codex-lb API key updated (${result.base_url || host}).` : `codex-lb key update failed: ${result.status}${result.error ? `: ${result.error}` : ''}`);
+        if (restart?.status === 'restarted')
+            console.log('Codex App restarted for the new codex-lb auth mode.');
         if (!result.ok)
             process.exitCode = 1;
         return;
     }
     if (action === 'use-codex-lb' || action === 'use-lb') {
         // Switch auth mode -> codex-lb (API key). Re-selects the provider and re-syncs auth.
-        const result = await repairCodexLbAuth();
+        const result = await repairCodexLbAuth({ forceCodexLbApiKeyAuth: true, authMode: 'codex-lb', forceFastMode: !flag(args, '--no-fast') });
+        const restart = await maybeRestartCodexAppForAuthSwitch(args, Boolean(result.ok));
         if (flag(args, '--json'))
-            return printJson({ ...result, mode: 'codex-lb' });
+            return printJson({ ...result, mode: 'codex-lb', restart_app: restart });
         console.log(result.ok ? 'Auth mode: codex-lb selected (API key).' : `Switch to codex-lb failed: ${result.status}${result.error ? `: ${result.error}` : ''}`);
+        if (restart?.status === 'restarted')
+            console.log('Codex App restarted for codex-lb auth.');
         if (!result.ok)
             process.exitCode = 1;
         return;
@@ -118,8 +167,9 @@ export async function run(command, args = []) {
     if (action === 'use-oauth' || action === 'use-chatgpt') {
         // Switch auth mode -> ChatGPT OAuth. Restores the saved OAuth login if present.
         const result = await releaseCodexLbAuthHold({ force: flag(args, '--force') });
+        const restart = await maybeRestartCodexAppForAuthSwitch(args, !['no_backup', 'auth_in_use', 'failed'].includes(result.status));
         if (flag(args, '--json'))
-            return printJson({ ...result, mode: 'oauth' });
+            return printJson({ ...result, mode: 'oauth', restart_app: restart });
         if (result.status === 'no_backup') {
             console.log('No saved ChatGPT OAuth credentials to restore. Switch to OAuth by logging in:');
             console.log('  codex login');
@@ -128,6 +178,8 @@ export async function run(command, args = []) {
             return;
         }
         console.log(`Auth mode: ${['released', 'oauth_restored'].includes(result.status) ? 'ChatGPT OAuth restored' : result.status}.`);
+        if (restart?.status === 'restarted')
+            console.log('Codex App restarted for ChatGPT OAuth.');
         if (['auth_in_use', 'failed'].includes(result.status))
             process.exitCode = 1;
         return;
@@ -224,6 +276,9 @@ export async function run(command, args = []) {
         const result = await configureCodexLb({
             host: options.host,
             apiKey: options.apiKey,
+            authMode: flag(args, '--preserve-auth') ? 'preserve' : 'codex-lb',
+            forceCodexLbApiKeyAuth: !flag(args, '--preserve-auth'),
+            forceFastMode: !flag(args, '--no-fast'),
             keychain: options.keychain,
             storeKeychain: options.keychain,
             useDefaultProvider: options.useDefaultProvider,
@@ -234,7 +289,9 @@ export async function run(command, args = []) {
             apiKeySource: options.apiKeySource,
             allowInsecureHttp: options.allowInsecureLocalhost
         });
+        const restart = await maybeRestartCodexAppForAuthSwitch(args, Boolean(result.ok) && !flag(args, '--preserve-auth'));
         const shaped = { schema: 'sks.codex-lb-setup.v1', ...result, api_key: { present: Boolean(options.apiKey), redacted: true }, env_file_chmod: '0600' };
+        shaped.restart_app = restart;
         if (options.health)
             shaped.applied_actions = [...(shaped.applied_actions || []), { type: 'run_health_check', target: 'codex-lb response chain', ok: true }];
         if (options.health)
@@ -284,6 +341,85 @@ export async function run(command, args = []) {
     console.error('  use-oauth     switch auth mode to ChatGPT OAuth (restores saved login, else: codex login)');
     process.exitCode = 1;
 }
+async function maybeRestartCodexAppForAuthSwitch(args = [], enabled) {
+    if (!enabled)
+        return { schema: 'sks.codex-app-restart.v1', ok: true, status: 'skipped', skipped: true, reason: 'previous_step_failed', app_name: 'Codex', blockers: [] };
+    const requested = flag(args, '--restart-app') || flag(args, '--restart');
+    const shouldRestart = requested || (!flag(args, '--json') && !flag(args, '--no-restart-app') && !flag(args, '--no-restart'));
+    return restartCodexApp({ enabled: shouldRestart });
+}
+async function fastEvidenceFromChain(chain = {}, requestLogPath = null) {
+    const chainEvidence = chain.service_tier_evidence || {};
+    const logRows = requestLogPath ? await readRequestLogRows(String(requestLogPath)) : [];
+    const logEvidence = serviceTierEvidenceFromRows(logRows);
+    const requested = logEvidence.requested_service_tier || chainEvidence.requested_service_tier || chain.requested_service_tier || null;
+    const actual = logEvidence.actual_service_tier || chainEvidence.actual_service_tier || null;
+    const effective = logEvidence.effective_service_tier || chainEvidence.effective_service_tier || null;
+    return {
+        requested_service_tier: requested,
+        actual_service_tier: actual,
+        effective_service_tier: effective,
+        fast_requested: requested === 'priority' || chain.requested_service_tier === 'priority' || chainEvidence.fast_requested === true,
+        fast_actual: actual === 'priority' || effective === 'priority' || logEvidence.fast_actual === true || chainEvidence.fast_actual === true,
+        chain_evidence: chainEvidence,
+        request_log_path: requestLogPath || null,
+        request_log_rows: logRows.length
+    };
+}
+async function readRequestLogRows(file) {
+    if (!file)
+        return [];
+    const text = await readText(path.isAbsolute(file) ? file : path.resolve(process.cwd(), file), '').catch(() => '');
+    const rows = [];
+    const trimmed = text.trim();
+    if (!trimmed)
+        return rows;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed))
+            return parsed;
+        if (Array.isArray(parsed?.rows))
+            return parsed.rows;
+        if (Array.isArray(parsed?.requests))
+            return parsed.requests;
+        return [parsed];
+    }
+    catch { }
+    for (const line of text.split(/\r?\n/)) {
+        const candidate = line.trim();
+        if (!candidate)
+            continue;
+        try {
+            rows.push(JSON.parse(candidate));
+        }
+        catch { }
+    }
+    return rows;
+}
+function serviceTierEvidenceFromRows(rows = []) {
+    let requested = null;
+    let actual = null;
+    let effective = null;
+    for (const row of rows) {
+        requested ||= normalizeTier(row?.requestedServiceTier || row?.requested_service_tier || row?.request?.service_tier || row?.body?.service_tier);
+        actual ||= normalizeTier(row?.actualServiceTier || row?.actual_service_tier || row?.response?.actualServiceTier);
+        effective ||= normalizeTier(row?.serviceTier || row?.service_tier || row?.response?.serviceTier);
+    }
+    return {
+        requested_service_tier: requested,
+        actual_service_tier: actual,
+        effective_service_tier: effective,
+        fast_actual: actual === 'priority' || effective === 'priority'
+    };
+}
+function normalizeTier(value) {
+    const text = String(value || '').trim().toLowerCase();
+    if (text === 'fast')
+        return 'priority';
+    if (text === 'priority' || text === 'default' || text === 'flex')
+        return text;
+    return null;
+}
 async function resolveNewApiKey(args = []) {
     const flagKey = readOption(args, '--api-key', '');
     if (flagKey)

package/dist/commands/doctor.js

@@ -801,9 +801,18 @@ async function runDoctor(args = [], root, doctorFix) {
     console.log(`  native agent_type: ${codexAppHarnessMatrix.app_features?.agent_type_supported ? 'ok' : 'fallback message-role'}`);
     console.log(`  init-deep memory: ${codexAppHarnessMatrix.sks_integrations?.init_deep_available ? 'available' : 'missing'}`);
     console.log(`  loop mesh app profile: ${codexAppHarnessMatrix.sks_integrations?.loop_mesh_app_profile_available ? 'available' : 'missing'}`);
+    const codexAppUiStatus = codexAppUi;
     console.log('Codex App UI:');
     console.log(`  fast selector: ${codexAppUi.fast_selector || 'unknown'}`);
     console.log(`  provider selector: ${codexAppUi.provider_selector || 'unknown'}`);
+    if (Array.isArray(codexAppUiStatus.provider_blockers) && codexAppUiStatus.provider_blockers.length) {
+        console.log(`  provider blockers: ${codexAppUiStatus.provider_blockers.join(', ')}`);
+    }
+    if (Array.isArray(codexAppUiStatus.provider_actions) && codexAppUiStatus.provider_actions.length) {
+        console.log('  provider actions:');
+        for (const action of codexAppUiStatus.provider_actions)
+            console.log(`    - ${action}`);
+    }
     console.log(`  host-owned config: ${codexAppUi.host_owned_config || 'unknown'}`);
     if (Array.isArray(codexAppUi.actions) && codexAppUi.actions.some((action) => action.changed)) {
         console.log('  repaired files:');

package/dist/core/codex-app/codex-app-fast-ui-repair.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { ensureDir, nowIso, readText, sha256, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { codexHome, scanProjectLocalForbiddenKeys, snapshotCodexAppUiState } from './codex-app-ui-state-snapshot.js';
 import { assertCodexAppUiMutationAllowed } from './codex-app-ui-clobber-guard.js';
+import { codexProviderModelUiStatus } from '../codex-app.js';
 export const CODEX_APP_FAST_UI_REPAIR_SCHEMA = 'sks.codex-app-fast-ui-repair.v1';
 const FAST_UI_TOP_LEVEL_RE = /^\s*(?:model|model_reasoning_effort|service_tier)\s*=/;
 const CODEX_APP_MODE_LOCK_TOP_LEVEL_RE = /^\s*(?:model|model_reasoning_effort)\s*=/;
@@ -61,6 +62,12 @@ export async function repairCodexAppFastUi(root = process.cwd(), input = {}) {
         });
     }
     const after = await snapshotCodexAppUiState(resolvedRoot, { codexHome: home });
+    const providerModelUi = await codexProviderModelUiStatus({
+        cwd: resolvedRoot,
+        home: path.dirname(home),
+        configPath: path.join(home, 'config.toml'),
+        codexLbEnvPath: path.join(home, 'sks-codex-lb.env')
+    });
     const changed = actions.some((action) => action.changed);
     const requiresConfirmation = unsafeReasons.length > 0 && input.force !== true;
     const safeAutoApply = changed && !requiresConfirmation;
@@ -81,7 +88,10 @@ export async function repairCodexAppFastUi(root = process.cwd(), input = {}) {
         detected_project_local_forbidden_keys: [...new Set(detectedProjectLocalForbiddenKeys)],
         unsafe_repair_reasons: [...new Set(unsafeReasons)],
         fast_selector: changed ? (input.apply ? 'repaired' : 'manual_action_required') : before.indicators.fast_selector === 'maybe_hidden_or_locked' ? 'manual_action_required' : 'ok',
-        provider_selector: 'ok',
+        provider_selector: providerModelUi.ok ? 'ok' : 'manual_action_required',
+        provider_model_ui: providerModelUi,
+        provider_actions: providerModelUi.ui_actions || [],
+        provider_blockers: providerModelUi.blockers || [],
         host_owned_config: input.apply && changed ? 'repaired_with_backup' : changed ? 'preserved_until_explicit_apply' : 'preserved',
         actions,
         before_fast_selector: before.indicators.fast_selector,

package/dist/core/codex-app/codex-app-restart.js

@@ -0,0 +1,65 @@
+import { exists, runProcess, which } from '../fsx.js';
+export async function restartCodexApp(opts = {}) {
+    const env = opts.env || process.env;
+    const appName = String(opts.appName || env.SKS_CODEX_APP_NAME || 'Codex');
+    if (opts.enabled === false || env.SKS_SKIP_CODEX_APP_RESTART === '1') {
+        return skipped(appName, 'disabled');
+    }
+    if (process.platform !== 'darwin')
+        return skipped(appName, 'not_macos');
+    const run = opts.runProcessImpl || runProcess;
+    const osascript = await which('osascript').catch(() => null) || await exists('/usr/bin/osascript').then((ok) => ok ? '/usr/bin/osascript' : null).catch(() => null);
+    const open = await which('open').catch(() => null) || await exists('/usr/bin/open').then((ok) => ok ? '/usr/bin/open' : null).catch(() => null);
+    if (!osascript || !open) {
+        return {
+            schema: 'sks.codex-app-restart.v1',
+            ok: false,
+            status: 'blocked',
+            app_name: appName,
+            blockers: [
+                ...(osascript ? [] : ['osascript_missing']),
+                ...(open ? [] : ['open_missing'])
+            ]
+        };
+    }
+    const quit = await run(osascript, ['-e', `tell application ${JSON.stringify(appName)} to quit`], { timeoutMs: 5000, maxOutputBytes: 8192 }).catch((err) => ({
+        code: 1,
+        stdout: '',
+        stderr: err?.message || String(err)
+    }));
+    await sleep(Number(opts.delayMs ?? env.SKS_CODEX_APP_RESTART_DELAY_MS ?? 1200));
+    const launched = await run(open, ['-a', appName], { timeoutMs: 10000, maxOutputBytes: 8192 }).catch((err) => ({
+        code: 1,
+        stdout: '',
+        stderr: err?.message || String(err)
+    }));
+    const quitOk = quit.code === 0 || /not running|Can't get application|application isn't running/i.test(String(quit.stderr || quit.stdout || ''));
+    const openOk = launched.code === 0;
+    return {
+        schema: 'sks.codex-app-restart.v1',
+        ok: quitOk && openOk,
+        status: quitOk && openOk ? 'restarted' : 'blocked',
+        app_name: appName,
+        quit: { ok: quitOk, code: quit.code, error: quitOk ? null : String(quit.stderr || quit.stdout || '').trim() },
+        open: { ok: openOk, code: launched.code, error: openOk ? null : String(launched.stderr || launched.stdout || '').trim() },
+        blockers: [
+            ...(quitOk ? [] : ['codex_app_quit_failed']),
+            ...(openOk ? [] : ['codex_app_open_failed'])
+        ]
+    };
+}
+function skipped(appName, reason) {
+    return {
+        schema: 'sks.codex-app-restart.v1',
+        ok: true,
+        status: 'skipped',
+        skipped: true,
+        reason,
+        app_name: appName,
+        blockers: []
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+//# sourceMappingURL=codex-app-restart.js.map