sneakoscope 7.1.0 → 7.3.0

package/dist/core/codex-app/desktop-routing-snapshot.js

@@ -0,0 +1,233 @@
+import fs from 'node:fs/promises';
+import { execFileSync } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import { nowIso, writeTextAtomic } from '../fsx.js';
+import { codexHomePath, readTopLevelTomlString } from './codex-model-catalog.js';
+import { ensureTrailingNewline, removeTopLevelTomlKeyIfValue, safeWriteCodexConfigToml, upsertTopLevelTomlString } from '../codex-runtime/codex-desktop-config-policy.js';
+import { invalidateCodexModelsCache } from './codex-models-cache.js';
+export const DESKTOP_ROUTING_SNAPSHOT_SCHEMA = 'sks.codex-desktop-routing-snapshot.v1';
+export const DESKTOP_ROUTING_SNAPSHOT_FILENAME = 'sks-previous-desktop-routing.json';
+function snapshotPath(input = {}) {
+    return path.join(codexHomePath(input), DESKTOP_ROUTING_SNAPSHOT_FILENAME);
+}
+export function desktopRoutingSnapshotPath(input = {}) {
+    return snapshotPath(input);
+}
+function threadCatalogDbPath(input = {}) {
+    return path.join(codexHomePath(input), 'sqlite', 'codex-dev.db');
+}
+function sqlQuote(value) {
+    return `'${String(value).replace(/'/g, "''")}'`;
+}
+function runSqlite3(dbPath, sql) {
+    return execFileSync('sqlite3', ['-batch', '-noheader', dbPath, sql], {
+        encoding: 'utf8',
+        timeout: 10_000,
+        maxBuffer: 2 * 1024 * 1024
+    });
+}
+export function captureDesktopRoutingSnapshot(configText, input) {
+    return {
+        schema: DESKTOP_ROUTING_SNAPSHOT_SCHEMA,
+        captured_at: nowIso(),
+        reason: input.reason,
+        model_provider: readTopLevelTomlString(configText, 'model_provider'),
+        model: readTopLevelTomlString(configText, 'model'),
+        model_catalog_json: readTopLevelTomlString(configText, 'model_catalog_json'),
+        openai_base_url: readTopLevelTomlString(configText, 'openai_base_url'),
+        ...(input.threadSidebar ? { thread_sidebar: input.threadSidebar } : {})
+    };
+}
+export async function writeDesktopRoutingSnapshot(snapshot, input = {}) {
+    const filePath = snapshotPath(input);
+    try {
+        await writeTextAtomic(filePath, `${JSON.stringify(snapshot, null, 2)}\n`, { mode: 0o600 });
+        return { ok: true, path: filePath };
+    }
+    catch (err) {
+        return { ok: false, path: filePath, error: err?.message || String(err) };
+    }
+}
+export async function readDesktopRoutingSnapshot(input = {}) {
+    const filePath = snapshotPath(input);
+    try {
+        const raw = await fs.readFile(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || parsed.schema !== DESKTOP_ROUTING_SNAPSHOT_SCHEMA)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function assessThreadVisibilityImpact(input) {
+    const catalogDb = threadCatalogDbPath(input);
+    const warnings = [];
+    const counts = {};
+    let checked = false;
+    try {
+        const raw = runSqlite3(catalogDb, 'SELECT model_provider, COUNT(*) FROM local_thread_catalog GROUP BY model_provider;');
+        for (const line of raw.split(/\n/).map((entry) => entry.trim()).filter(Boolean)) {
+            const sep = line.includes('|') ? '|' : '\t';
+            const [provider, count] = line.split(sep);
+            counts[String(provider || 'unknown')] = Number(count || 0);
+        }
+        checked = true;
+    }
+    catch (err) {
+        warnings.push(`thread_catalog_unreadable:${err?.code || err?.message || 'unknown'}`);
+    }
+    const target = String(input.targetProvider || '').trim();
+    const hidden = Object.entries(counts)
+        .filter(([provider]) => provider !== target)
+        .reduce((sum, [, count]) => sum + count, 0);
+    if (checked && hidden > 0) {
+        warnings.push('desktop_hides_other_provider_threads_until_restore');
+    }
+    return {
+        schema: 'sks.codex-desktop-thread-visibility.v1',
+        checked,
+        catalog_db: checked ? catalogDb : null,
+        current_provider: input.currentProvider,
+        target_provider: target,
+        counts_by_provider: counts,
+        hidden_if_switched: hidden,
+        warnings
+    };
+}
+export function remapThreadCatalogProvider(input) {
+    const catalogDb = threadCatalogDbPath(input);
+    const fromProvider = String(input.fromProvider || '').trim();
+    const toProvider = String(input.toProvider || '').trim();
+    if (!fromProvider || !toProvider || fromProvider === toProvider) {
+        return { ok: true, remapped: 0, thread_ids: [], catalog_db: catalogDb };
+    }
+    try {
+        const idRaw = runSqlite3(catalogDb, `SELECT thread_id FROM local_thread_catalog WHERE model_provider = ${sqlQuote(fromProvider)};`);
+        const ids = idRaw.split(/\n/).map((entry) => entry.trim()).filter(Boolean);
+        if (ids.length === 0) {
+            return { ok: true, remapped: 0, thread_ids: [], catalog_db: catalogDb };
+        }
+        runSqlite3(catalogDb, `UPDATE local_thread_catalog SET model_provider = ${sqlQuote(toProvider)} WHERE model_provider = ${sqlQuote(fromProvider)};`);
+        return {
+            ok: true,
+            remapped: ids.length,
+            thread_ids: ids,
+            catalog_db: catalogDb
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            remapped: 0,
+            thread_ids: [],
+            catalog_db: catalogDb,
+            error: err?.message || String(err)
+        };
+    }
+}
+export async function restoreDesktopRoutingSnapshot(input) {
+    const home = input.home || input.env?.HOME || os.homedir();
+    const env = { ...(input.env || process.env), HOME: home };
+    const snapshot = await readDesktopRoutingSnapshot({ home, env });
+    if (!snapshot) {
+        return {
+            schema: 'sks.codex-app-restore-desktop-routing.v1',
+            ok: false,
+            status: 'snapshot_missing',
+            blockers: ['desktop_routing_snapshot_missing'],
+            warnings: [],
+            hint: 'No previous Desktop routing snapshot. Use sks codex-lb use-codex-lb or Restore Chat / Pro.'
+        };
+    }
+    const configPath = input.configPath || path.join(codexHomePath({ home, env }), 'config.toml');
+    const before = await fs.readFile(configPath, 'utf8').catch(() => '');
+    let next = before;
+    if (snapshot.model_provider)
+        next = upsertTopLevelTomlString(next, 'model_provider', snapshot.model_provider);
+    else
+        next = removeTopLevelTomlKeyIfValue(next, 'model_provider', readTopLevelTomlString(next, 'model_provider') || '');
+    if (snapshot.model)
+        next = upsertTopLevelTomlString(next, 'model', snapshot.model);
+    else
+        next = removeTopLevelTomlKeyIfValue(next, 'model', readTopLevelTomlString(next, 'model') || '');
+    if (snapshot.model_catalog_json) {
+        next = upsertTopLevelTomlString(next, 'model_catalog_json', snapshot.model_catalog_json);
+    }
+    else {
+        next = removeTopLevelTomlKeyIfValue(next, 'model_catalog_json', readTopLevelTomlString(next, 'model_catalog_json') || '');
+    }
+    next = ensureTrailingNewline(next);
+    const write = await safeWriteCodexConfigToml(configPath, before, next, 'restore-desktop-routing', { verifyUnchangedBeforeWrite: true, expectedBeforeExists: Boolean(before) });
+    if (!write.ok) {
+        return {
+            schema: 'sks.codex-app-restore-desktop-routing.v1',
+            ok: false,
+            status: 'config_write_blocked',
+            snapshot,
+            write,
+            blockers: [String(write.status || 'restore_config_write_blocked')],
+            warnings: []
+        };
+    }
+    let sidebarRestore = null;
+    if (snapshot.thread_sidebar?.remapped) {
+        const remapped = remapThreadCatalogProvider({
+            home,
+            env,
+            fromProvider: snapshot.thread_sidebar.to_provider,
+            toProvider: snapshot.thread_sidebar.from_provider
+        });
+        sidebarRestore = { ...remapped, expected_ids: snapshot.thread_sidebar.thread_ids.length };
+    }
+    const cache = await invalidateCodexModelsCache({
+        home,
+        env,
+        catalogPath: snapshot.model_catalog_json,
+        seedMode: 'merge'
+    });
+    const restart = await (input.restartImpl
+        ? input.restartImpl({ enabled: Boolean(input.restartApp) })
+        : Promise.resolve({ ok: true, blockers: [] }));
+    const sidebarRestoreOk = sidebarRestore === null || sidebarRestore.ok === true;
+    if (sidebarRestoreOk) {
+        try {
+            await fs.unlink(snapshotPath({ home, env }));
+        }
+        catch {
+        }
+    }
+    const sidebarBlocker = sidebarRestoreOk
+        ? []
+        : [`thread_sidebar_restore_failed:${String(sidebarRestore?.error || 'unknown')}`];
+    const sidebarRemapped = Number(sidebarRestore?.remapped ?? 0);
+    const sidebarExpected = Number(sidebarRestore?.expected_ids ?? 0);
+    const sidebarPartial = sidebarRestoreOk && sidebarRestore !== null && sidebarRemapped < sidebarExpected;
+    const sidebarWarning = sidebarPartial
+        ? [`thread_sidebar_restore_partial:${sidebarRemapped}_of_${sidebarExpected}`]
+        : [];
+    return {
+        schema: 'sks.codex-app-restore-desktop-routing.v1',
+        ok: Boolean(write.ok && restart.ok && sidebarRestoreOk),
+        status: !sidebarRestoreOk
+            ? (restart.ok ? 'restored_sidebar_blocked' : 'restored_sidebar_and_restart_blocked')
+            : restart.ok ? 'restored' : 'restored_restart_blocked',
+        snapshot,
+        write,
+        thread_sidebar_restore: sidebarRestore,
+        thread_sidebar_restore_ok: sidebarRestoreOk,
+        snapshot_retained: !sidebarRestoreOk,
+        models_cache: cache,
+        restart_app: restart,
+        blockers: [
+            ...sidebarBlocker,
+            ...(restart.ok ? [] : (restart.blockers || ['restore_restart_blocked']))
+        ],
+        warnings: [...sidebarWarning, ...(cache.warnings || [])],
+        hint: sidebarRestoreOk
+            ? 'Codex Desktop may need a full quit/reopen for the sidebar and picker to refresh.'
+            : 'Routing was restored but prior-provider chats stay hidden. Fully quit Codex Desktop, then re-run sks codex-app restore-desktop-routing — the snapshot was kept for that retry.'
+    };
+}

package/dist/core/codex-app/glm-profile-installer.js

@@ -3,6 +3,7 @@ import { codexLbConfigPath, ensureGlobalCodexAppGlmProfile } from '../../cli/ins
 import { readText, writeJsonAtomic, nowIso, rmrf } from '../fsx.js';
 import { OPENROUTER_DEFAULT_PROFILE_ID, OPENROUTER_AUTH_COMMAND, OPENROUTER_AUTH_REFRESH_INTERVAL_MS, OPENROUTER_AUTH_TIMEOUT_MS, openRouterAuthCommandArgs, OPENROUTER_PROVIDER_ID, RETIRED_GLM_DESKTOP_CONFIG_PROFILE_IDS, buildGlmCodexAppModelProfile } from './openrouter-provider.js';
 import { openRouterSecretPaths, resolveOpenRouterApiKey } from '../providers/openrouter/openrouter-secret-store.js';
+import { escapeRegExp } from '../text/regex.js';
 export async function installCodexAppGlmProfile(input) {
     const root = path.resolve(input.root);
     const profile = buildGlmCodexAppModelProfile();
@@ -188,6 +189,3 @@ function hasTomlStringArray(text, key, values) {
 function hasTomlInteger(text, key, value) {
     return new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*${value}\\s*(?:#.*)?$`, 'm').test(text);
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

package/dist/core/codex-app/mcp-manager.js

@@ -1,6 +1,7 @@
 import os from 'node:os';
 import path from 'node:path';
 import { addMcpServer, listMcpInventory, MCP_INVENTORY_SCHEMA, MCP_MUTATION_SCHEMA, removeMcpServer, setMcpServerEnabled } from '../mcp-config/index.js';
+import { isRecord } from '../json/records.js';
 export const CODEX_MCP_LIST_SCHEMA = MCP_INVENTORY_SCHEMA;
 export const CODEX_MCP_MUTATION_SCHEMA = MCP_MUTATION_SCHEMA;
 export function codexMcpConfigPath(homeInput) {
@@ -68,7 +69,4 @@ function scopeOptions(options) {
         ...(options.cli ? { cli: options.cli } : {})
     };
 }
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
 export * from '../mcp-config/index.js';

package/dist/core/codex-app/menubar/constants.js

@@ -15,11 +15,14 @@ export const NATIVE_SOURCE_FILES = [
     'StatusItemController.swift',
     'ControlCenterWindowController.swift',
     'SidebarItem.swift',
+    'ControlKit.swift',
     'OverviewViewController.swift',
     'UpdatesViewController.swift',
     'MCPServersViewController.swift',
     'ProvidersViewController.swift',
     'ProvidersOpenRouter.swift',
+    'ProvidersRoleModels.swift',
+    'ProvidersMultiProvider.swift',
     'RemoteTelegramViewController.swift',
     'DiagnosticsViewController.swift',
     'SettingsViewController.swift',

package/dist/core/codex-app/menubar/installer.js

@@ -15,6 +15,10 @@ import { infoPlistSource, inspectInstalledResources, loadNativeMenuBarSources, n
 import { inspectMenuBarArtifactSet, normalizeLegacyMenuBarBuildStamp, rollbackSksMenuBar } from './rollback.js';
 import { inspectSignature } from './signature.js';
 import { defaultNextActions, inspectSksMenuBarStatus, isMenuBarInstallPathUnderTempDir } from './status.js';
+export function sksMenuBarRestartDeferred(env = process.env) {
+    return env.SKS_UPDATE_DEFER_MENUBAR_RESTART === '1'
+        || env.SKS_SKIP_SKS_MENUBAR_LAUNCH === '1';
+}
 export async function installSksMenuBar(opts = {}) {
     const apply = opts.apply === true;
     const env = opts.env || process.env;
@@ -261,7 +265,13 @@ export async function installSksMenuBar(opts = {}) {
             transaction = committed;
         }
     }
-    const launchWanted = opts.launch !== false && env.SKS_SKIP_SKS_MENUBAR_LAUNCH !== '1';
+    const restartDeferred = sksMenuBarRestartDeferred(env);
+    const launchWanted = opts.launch !== false
+        && env.SKS_SKIP_SKS_MENUBAR_LAUNCH !== '1'
+        && !restartDeferred;
+    if (restartDeferred && opts.launch !== false && env.SKS_SKIP_SKS_MENUBAR_LAUNCH !== '1') {
+        warnings.push('launch_deferred_until_parent_operation_completes');
+    }
     const launchAllowed = path.resolve(paths.home) === realUserHome() && !isMenuBarInstallPathUnderTempDir(paths.executable_path, env);
     if (launchWanted && path.resolve(paths.home) !== realUserHome())
         warnings.push('launch_skipped_non_user_home');

package/dist/core/codex-app/multi-provider-router-support.js

@@ -0,0 +1,202 @@
+import os from 'node:os';
+import path from 'node:path';
+import { nowIso } from '../fsx.js';
+import { codexHomePath, defaultOpenCodexCatalogPath, normalizeCodexModelId, sksOpenRouterCatalogPath } from './codex-model-catalog.js';
+import { escapeRegExp } from '../text/regex.js';
+import { isRecord } from '../json/records.js';
+import { uniqueStrings } from '../text/strings.js';
+export { uniqueStrings };
+const MULTI_PROVIDER_ROUTER_MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
+export async function probeRouterModels(input) {
+    const url = `${input.baseUrl.replace(/\/+$/, '')}/models`;
+    try {
+        const response = await input.fetchImpl(url, {
+            method: 'GET',
+            headers: { accept: 'application/json' },
+            redirect: 'error',
+            signal: AbortSignal.timeout(input.timeoutMs)
+        });
+        const length = Number(response.headers.get('content-length') || 0);
+        if (length > MULTI_PROVIDER_ROUTER_MAX_RESPONSE_BYTES) {
+            return oversizedModelsResponse(response.status, url);
+        }
+        if (!response.ok) {
+            return {
+                ok: false,
+                status: response.status,
+                url,
+                models: [],
+                blockers: [`multi_provider_router_models_http_${response.status}`]
+            };
+        }
+        const body = await readResponseTextBounded(response, MULTI_PROVIDER_ROUTER_MAX_RESPONSE_BYTES);
+        const models = liveModelIds(JSON.parse(body));
+        return {
+            ok: models.length > 0,
+            status: response.status,
+            url,
+            models,
+            blockers: models.length ? [] : ['multi_provider_router_live_models_empty']
+        };
+    }
+    catch (err) {
+        const name = String(err?.name || '');
+        const message = String(err?.message || '');
+        return {
+            ok: false,
+            status: null,
+            url,
+            models: [],
+            blockers: [
+                name === 'TimeoutError'
+                    ? 'multi_provider_router_probe_timeout'
+                    : message === 'multi_provider_router_models_response_too_large'
+                        ? message
+                        : err instanceof SyntaxError
+                            ? 'multi_provider_router_models_json_invalid'
+                            : 'multi_provider_router_probe_failed'
+            ]
+        };
+    }
+}
+export function resolveCatalogPath(value, input) {
+    const env = input.env || process.env;
+    const home = input.home || env.HOME || os.homedir();
+    const trimmed = String(value || '').trim();
+    if (trimmed === '~')
+        return path.resolve(home);
+    if (trimmed.startsWith('~/'))
+        return path.resolve(home, trimmed.slice(2));
+    if (!path.isAbsolute(trimmed)) {
+        return path.resolve(input.configPath ? path.dirname(input.configPath) : codexHomePath({ home, env }), trimmed);
+    }
+    return path.resolve(trimmed);
+}
+export function isSksManagedCatalogPath(filePath, input) {
+    if (!filePath)
+        return false;
+    const env = input.env || process.env;
+    const home = input.home || env.HOME || os.homedir();
+    const codexHome = codexHomePath({ home, env });
+    return [
+        defaultOpenCodexCatalogPath({ home, env }),
+        sksOpenRouterCatalogPath({ home, env }),
+        path.join(codexHome, 'sks-codex-lb-tool-catalog.json')
+    ].some((candidate) => path.resolve(candidate) === path.resolve(filePath));
+}
+export function isLoopbackHostname(value) {
+    const hostname = String(value || '').trim().toLowerCase();
+    return hostname === 'localhost'
+        || hostname === '127.0.0.1'
+        || hostname === '::1'
+        || hostname === '[::1]';
+}
+export function tomlTableBody(text, table) {
+    const header = `[${table}]`;
+    const lines = String(text || '').split('\n');
+    const start = lines.findIndex((line) => line.trim() === header);
+    if (start === -1)
+        return '';
+    const body = [];
+    for (let index = start + 1; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (/^\s*\[[^\]]+\]\s*(?:#.*)?$/.test(line || ''))
+            break;
+        body.push(line || '');
+    }
+    return body.join('\n');
+}
+export function tomlString(text, key) {
+    const match = String(text || '').match(new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"((?:\\\\.|[^"])*)"\\s*(?:#.*)?$`, 'm'));
+    if (!match)
+        return null;
+    try {
+        return JSON.parse(`"${match[1] || ''}"`);
+    }
+    catch {
+        return match[1] || '';
+    }
+}
+export function tomlBoolean(text, key) {
+    const match = String(text || '').match(new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*(true|false)\\s*(?:#.*)?$`, 'mi'));
+    if (!match)
+        return null;
+    return match[1]?.toLowerCase() === 'true';
+}
+export function hasTomlKey(text, key) {
+    return new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`, 'm').test(text);
+}
+export function hasUnexpectedTomlKeys(text, allowedKeys) {
+    const allowed = new Set(allowedKeys);
+    return String(text || '').split('\n').some((line) => {
+        const match = line.match(/^\s*([A-Za-z0-9_.-]+)\s*=/);
+        return Boolean(match?.[1] && !allowed.has(match[1]));
+    });
+}
+export function hasTomlTablePrefix(text, prefix) {
+    return String(text || '').split('\n').some((line) => {
+        const match = line.match(/^\s*\[([^\]]+)\]\s*(?:#.*)?$/);
+        return Boolean(match?.[1]?.startsWith(prefix));
+    });
+}
+export function routerBlocked(schema, ...blockers) {
+    return {
+        schema,
+        generated_at: nowIso(),
+        ok: false,
+        status: 'blocked',
+        blockers: uniqueStrings(blockers),
+        warnings: []
+    };
+}
+function liveModelIds(value) {
+    const rows = Array.isArray(value)
+        ? value
+        : isRecord(value) && Array.isArray(value.data)
+            ? value.data
+            : isRecord(value) && Array.isArray(value.models)
+                ? value.models
+                : [];
+    return uniqueStrings(rows.map((entry) => {
+        if (typeof entry === 'string')
+            return normalizeCodexModelId(entry);
+        if (!isRecord(entry))
+            return null;
+        return normalizeCodexModelId(entry.id || entry.model || entry.slug || entry.name);
+    }).filter((entry) => Boolean(entry)));
+}
+function oversizedModelsResponse(status, url) {
+    return {
+        ok: false,
+        status,
+        url,
+        models: [],
+        blockers: ['multi_provider_router_models_response_too_large']
+    };
+}
+async function readResponseTextBounded(response, maxBytes) {
+    if (!response.body)
+        return '';
+    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 Error('multi_provider_router_models_response_too_large');
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)), total).toString('utf8');
+}