sneakoscope 8.0.0 → 8.0.2

package/dist/cli/install-helpers-codex-lb-config.js

@@ -1,6 +1,9 @@
 import path from 'node:path';
 import os from 'node:os';
-import { ensureDir, readText } from '../core/fsx.js';
+import { constants as fsConstants } from 'node:fs';
+import fsp from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
+import { assertTestHomeWriteAllowed, ensureDir, readText, writeBinaryAtomic } from '../core/fsx.js';
 import { GLM_CODEX_CONFIG_PROVIDER_ID, GLM_52_OPENROUTER_MODEL, OPENROUTER_AUTH_COMMAND, OPENROUTER_AUTH_REFRESH_INTERVAL_MS, OPENROUTER_AUTH_TIMEOUT_MS, openRouterAuthCommandArgs, OPENROUTER_DEFAULT_PROFILE_ID, RETIRED_GLM_DESKTOP_CONFIG_PROFILE_IDS } from '../core/codex-app/openrouter-provider.js';
 import { openRouterSecretPaths, resolveOpenRouterApiKey } from '../core/providers/openrouter/openrouter-secret-store.js';
 import { reconcileRetiredSksConfigText } from '../core/auto-review.js';
@@ -290,17 +293,481 @@ export function detectCodexLbSetupDrift(state = {}) {
         drift.push('shell_profile_changed_despite_skip');
     return drift;
 }
-export async function captureCodexLbSetupWriteState({ home, configPath, envPath, shellProfile } = {}) {
+export async function captureCodexLbSetupWriteState({ home, configPath, envPath, metadataPath, shellProfile } = {}) {
     const profileFiles = profileFilesForDrift(home, shellProfile);
+    const paths = [configPath, envPath, metadataPath, ...profileFiles].filter(Boolean);
+    const files = await Promise.all(paths.map(captureSetupFile));
+    const hashesByPath = new Map(await Promise.all(files.map(async (file) => [file.path, await capturedSetupFileHash(file)])));
+    const hashForPath = (file) => file ? hashesByPath.get(file) || 'missing' : 'missing';
     return {
-        configHash: await fileHashOrMissing(configPath),
-        envHash: await fileHashOrMissing(envPath),
-        profileHash: (await Promise.all(profileFiles.map((file) => fileHashOrMissing(file)))).join('|')
+        configHash: hashForPath(configPath),
+        envHash: hashForPath(envPath),
+        metadataHash: hashForPath(metadataPath),
+        profileHash: profileFiles.map(hashForPath).join('|'),
+        files,
+        stateHash: await sha256Text(JSON.stringify(files))
     };
 }
-async function fileHashOrMissing(file) {
-    const text = await readText(file, null).catch(() => null);
-    return text === null ? 'missing' : await sha256Text(String(text));
+export async function writeCodexLbSetupFileIfUnchanged(input) {
+    const file = path.resolve(input.file);
+    if (path.resolve(String(input.expected.path || '')) !== file) {
+        return {
+            ok: false,
+            status: 'write_failed',
+            installed: false,
+            expected_after: {
+                path: file,
+                existed: true,
+                kind: 'regular',
+                bytes_base64: Buffer.from(input.text).toString('base64'),
+                mode: Number(input.mode) & 0o777
+            },
+            error: 'setup_snapshot_path_mismatch'
+        };
+    }
+    const expected = { ...input.expected, path: file };
+    const mode = Number(input.mode) & 0o777;
+    const expectedAfter = {
+        path: file,
+        existed: true,
+        kind: 'regular',
+        bytes_base64: Buffer.from(input.text).toString('base64'),
+        mode
+    };
+    if (expected.existed === true && expected.kind !== 'regular') {
+        return {
+            ok: false,
+            status: 'unsafe_setup_write_target',
+            installed: false,
+            expected_after: expectedAfter
+        };
+    }
+    assertTestHomeWriteAllowed(file);
+    await ensureDir(path.dirname(file));
+    const token = `${Date.now().toString(36)}-${process.pid}-${randomBytes(6).toString('hex')}`;
+    const claimedPath = `${file}.sks-setup-claimed-${token}`;
+    const candidatePath = `${file}.sks-setup-candidate-${token}`;
+    let claimed = false;
+    let installed = false;
+    try {
+        await writeBinaryAtomic(candidatePath, Buffer.from(input.text), { mode });
+        const observed = await captureSetupFile(file);
+        if (!setupFileStatesEqual(observed, expected)) {
+            return {
+                ok: false,
+                status: 'concurrent_change_detected',
+                installed: false,
+                expected_after: expectedAfter
+            };
+        }
+        if (setupFileStatesEqual(expected, expectedAfter)) {
+            return {
+                ok: true,
+                status: 'present',
+                installed: false,
+                expected_after: expectedAfter
+            };
+        }
+        if (expected.existed === true) {
+            try {
+                await fsp.rename(file, claimedPath);
+                claimed = true;
+            }
+            catch {
+                return {
+                    ok: false,
+                    status: 'concurrent_change_detected',
+                    installed: false,
+                    expected_after: expectedAfter
+                };
+            }
+            const claimedState = await captureSetupFile(claimedPath);
+            if (!setupFileStatesEqual(claimedState, { ...expected, path: claimedPath })) {
+                const recovered = await restoreClaimedSetupPathIfAbsent(claimedPath, file, claimedState);
+                claimed = !recovered;
+                const hardened = !claimed || await hardenCodexLbSetupRecoveryPath(claimedPath);
+                return {
+                    ok: false,
+                    status: hardened ? 'concurrent_change_detected' : 'write_failed',
+                    installed: false,
+                    expected_after: expectedAfter,
+                    ...(claimed ? { recovery_path: claimedPath } : {}),
+                    ...(hardened ? {} : { error: 'setup_recovery_mode_hardening_failed' })
+                };
+            }
+        }
+        await input.beforeReplacement?.({ path: file });
+        try {
+            await fsp.link(candidatePath, file);
+            installed = true;
+        }
+        catch {
+            if (claimed) {
+                const claimedState = await captureSetupFile(claimedPath).catch(() => null);
+                const recovered = claimedState
+                    ? await restoreClaimedSetupPathIfAbsent(claimedPath, file, claimedState)
+                    : false;
+                claimed = !recovered;
+            }
+            const hardened = !claimed || await hardenCodexLbSetupRecoveryPath(claimedPath);
+            return {
+                ok: false,
+                status: hardened ? 'concurrent_change_detected' : 'write_failed',
+                installed: false,
+                expected_after: expectedAfter,
+                ...(claimed ? { recovery_path: claimedPath } : {}),
+                ...(hardened ? {} : { error: 'setup_recovery_mode_hardening_failed' })
+            };
+        }
+        const committed = await captureSetupFile(file);
+        if (!setupFileStatesEqual(committed, expectedAfter)) {
+            const hardened = !claimed || await hardenCodexLbSetupRecoveryPath(claimedPath);
+            return {
+                ok: false,
+                status: hardened ? 'concurrent_change_detected' : 'write_failed',
+                installed: true,
+                expected_after: expectedAfter,
+                ...(claimed ? { recovery_path: claimedPath } : {}),
+                ...(hardened ? {} : { error: 'setup_recovery_mode_hardening_failed' })
+            };
+        }
+        if (claimed && !await hardenCodexLbSetupRecoveryPath(claimedPath)) {
+            return {
+                ok: false,
+                status: 'write_failed',
+                installed: true,
+                expected_after: expectedAfter,
+                recovery_path: claimedPath,
+                error: 'setup_recovery_mode_hardening_failed'
+            };
+        }
+        return {
+            ok: true,
+            status: 'written',
+            installed: true,
+            expected_after: expectedAfter,
+            ...(claimed ? { recovery_path: claimedPath } : {})
+        };
+    }
+    catch (error) {
+        if (claimed && !installed) {
+            const claimedState = await captureSetupFile(claimedPath).catch(() => null);
+            const recovered = claimedState
+                ? await restoreClaimedSetupPathIfAbsent(claimedPath, file, claimedState)
+                : false;
+            claimed = !recovered;
+        }
+        const hardened = !claimed || await hardenCodexLbSetupRecoveryPath(claimedPath);
+        return {
+            ok: false,
+            status: 'write_failed',
+            installed,
+            expected_after: expectedAfter,
+            ...(claimed ? { recovery_path: claimedPath } : {}),
+            error: [
+                error instanceof Error ? error.message : String(error),
+                ...(hardened ? [] : ['setup_recovery_mode_hardening_failed'])
+            ].join(':')
+        };
+    }
+    finally {
+        await fsp.rm(candidatePath, { force: true }).catch(() => undefined);
+    }
+}
+export async function hardenCodexLbSetupRecoveryPath(file) {
+    let handle = null;
+    try {
+        handle = await fsp.open(file, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+        const before = await handle.stat();
+        if (!before.isFile())
+            return false;
+        await handle.chmod(0o600);
+        const hardened = await handle.stat();
+        const pathStat = await fsp.lstat(file);
+        return hardened.isFile()
+            && (hardened.mode & 0o777) === 0o600
+            && pathStat.isFile()
+            && !pathStat.isSymbolicLink()
+            && pathStat.dev === hardened.dev
+            && pathStat.ino === hardened.ino;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+export async function removeCodexLbSetupRecoveryPath(file) {
+    if (!path.basename(file).includes('.sks-setup-claimed-'))
+        return false;
+    let handle = null;
+    try {
+        handle = await fsp.open(file, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+        const opened = await handle.stat();
+        const pathStat = await fsp.lstat(file);
+        if (!opened.isFile()
+            || !pathStat.isFile()
+            || pathStat.isSymbolicLink()
+            || pathStat.dev !== opened.dev
+            || pathStat.ino !== opened.ino)
+            return false;
+        await fsp.unlink(file);
+        return await fsp.lstat(file).then(() => false, (error) => error.code === 'ENOENT');
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+export async function restoreCodexLbSetupWriteState(state, expectedCurrentState, opts = {}) {
+    const restored = [];
+    const removed = [];
+    const blockers = [];
+    const recovery = [];
+    const expectedByPath = new Map((Array.isArray(expectedCurrentState?.files) ? expectedCurrentState.files : [])
+        .map((entry) => [String(entry?.path || ''), entry]));
+    for (const entry of Array.isArray(state?.files) ? [...state.files].reverse() : []) {
+        const file = String(entry?.path || '');
+        if (!file)
+            continue;
+        try {
+            const expected = expectedByPath.get(file);
+            if (!expected) {
+                blockers.push(`setup_rollback_missing_expected_state:${file}`);
+                continue;
+            }
+            if (expected && setupFileStatesEqual(entry, expected))
+                continue;
+            const commit = await commitSetupRollbackIfUnchanged({
+                file,
+                before: entry,
+                expected,
+                ...(opts.beforeReplacement ? { beforeReplacement: opts.beforeReplacement } : {})
+            });
+            if (commit.recoveryPath)
+                recovery.push(commit.recoveryPath);
+            if (!commit.ok) {
+                blockers.push(`${commit.failed ? 'setup_rollback_failed' : 'setup_rollback_conflict'}:${file}`);
+                continue;
+            }
+            if (commit.restored)
+                restored.push(file);
+            if (commit.removed)
+                removed.push(file);
+        }
+        catch {
+            blockers.push(`setup_rollback_failed:${file}`);
+        }
+    }
+    return { ok: blockers.length === 0, restored, removed, blockers, recovery };
+}
+function setupFileStatesEqual(left, right) {
+    return left?.existed === right?.existed
+        && String(left?.kind || (left?.existed ? 'regular' : 'missing')) === String(right?.kind || (right?.existed ? 'regular' : 'missing'))
+        && String(left?.bytes_base64 || '') === String(right?.bytes_base64 || '')
+        && (left?.existed !== true || Number(left?.mode) === Number(right?.mode));
+}
+async function captureSetupFile(file) {
+    let pathStat;
+    try {
+        pathStat = await fsp.lstat(file);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return { path: file, existed: false, kind: 'missing', bytes_base64: '', mode: null };
+        }
+        throw error;
+    }
+    if (pathStat.isSymbolicLink()) {
+        return { path: file, existed: true, kind: 'symlink', bytes_base64: '', mode: pathStat.mode & 0o777 };
+    }
+    if (!pathStat.isFile()) {
+        return { path: file, existed: true, kind: 'non_regular', bytes_base64: '', mode: pathStat.mode & 0o777 };
+    }
+    let handle = null;
+    try {
+        handle = await fsp.open(file, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+        const stat = await handle.stat();
+        if (!stat.isFile()) {
+            return { path: file, existed: true, kind: 'non_regular', bytes_base64: '', mode: stat.mode & 0o777 };
+        }
+        const bytes = await handle.readFile();
+        return {
+            path: file,
+            existed: true,
+            kind: 'regular',
+            bytes_base64: bytes.toString('base64'),
+            mode: stat.mode & 0o777
+        };
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return { path: file, existed: false, kind: 'missing', bytes_base64: '', mode: null };
+        }
+        if (error?.code === 'ELOOP') {
+            const stat = await fsp.lstat(file).catch(() => null);
+            return {
+                path: file,
+                existed: true,
+                kind: 'symlink',
+                bytes_base64: '',
+                mode: stat ? stat.mode & 0o777 : null
+            };
+        }
+        throw error;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+async function commitSetupRollbackIfUnchanged(input) {
+    const { file, before, expected } = input;
+    await ensureDir(path.dirname(file));
+    const token = `${Date.now().toString(36)}-${process.pid}-${randomBytes(6).toString('hex')}`;
+    const claimedPath = `${file}.sks-rollback-claimed-${token}`;
+    const candidatePath = `${file}.sks-rollback-candidate-${token}`;
+    let claimed = false;
+    try {
+        if (expected.existed === true) {
+            const currentStat = await fsp.lstat(file).catch((error) => {
+                if (error.code === 'ENOENT')
+                    return null;
+                throw error;
+            });
+            if (!currentStat || currentStat.isSymbolicLink() || !currentStat.isFile()) {
+                return { ok: false, restored: false, removed: false };
+            }
+            try {
+                await fsp.rename(file, claimedPath);
+                claimed = true;
+            }
+            catch {
+                return { ok: false, restored: false, removed: false };
+            }
+            const claimedState = await captureSetupFile(claimedPath);
+            if (!setupFileStatesEqual(claimedState, { ...expected, path: claimedPath })) {
+                const recovered = await restoreClaimedSetupPathIfAbsent(claimedPath, file, claimedState);
+                claimed = !recovered;
+                return {
+                    ok: false,
+                    restored: false,
+                    removed: false,
+                    ...(claimed ? { recoveryPath: claimedPath } : {})
+                };
+            }
+        }
+        else {
+            const current = await captureSetupFile(file);
+            if (!setupFileStatesEqual(current, expected)) {
+                return { ok: false, restored: false, removed: false };
+            }
+        }
+        await input.beforeReplacement?.({ path: file });
+        if (before.existed === true) {
+            if (String(before.kind || 'regular') !== 'regular') {
+                if (claimed) {
+                    const claimedState = await captureSetupFile(claimedPath);
+                    const recovered = await restoreClaimedSetupPathIfAbsent(claimedPath, file, claimedState);
+                    claimed = !recovered;
+                }
+                return {
+                    ok: false,
+                    restored: false,
+                    removed: false,
+                    failed: true,
+                    ...(claimed ? { recoveryPath: claimedPath } : {})
+                };
+            }
+            const bytes = Buffer.from(String(before.bytes_base64 || ''), 'base64');
+            await writeBinaryAtomic(candidatePath, bytes, { mode: Number(before.mode || 0o600) });
+            try {
+                await fsp.link(candidatePath, file);
+            }
+            catch {
+                return {
+                    ok: false,
+                    restored: false,
+                    removed: false,
+                    ...(claimed ? { recoveryPath: claimedPath } : {})
+                };
+            }
+            const committed = await captureSetupFile(file);
+            if (!setupFileStatesEqual(committed, before)) {
+                return {
+                    ok: false,
+                    restored: false,
+                    removed: false,
+                    ...(claimed ? { recoveryPath: claimedPath } : {})
+                };
+            }
+            return {
+                ok: true,
+                restored: true,
+                removed: false,
+                ...(claimed ? { recoveryPath: claimedPath } : {})
+            };
+        }
+        const committed = await captureSetupFile(file);
+        if (!setupFileStatesEqual(committed, before)) {
+            return {
+                ok: false,
+                restored: false,
+                removed: false,
+                ...(claimed ? { recoveryPath: claimedPath } : {})
+            };
+        }
+        return {
+            ok: true,
+            restored: false,
+            removed: true,
+            ...(claimed ? { recoveryPath: claimedPath } : {})
+        };
+    }
+    catch {
+        if (claimed) {
+            const claimedState = await captureSetupFile(claimedPath).catch(() => null);
+            const recovered = claimedState
+                ? await restoreClaimedSetupPathIfAbsent(claimedPath, file, claimedState)
+                : false;
+            claimed = !recovered;
+        }
+        return {
+            ok: false,
+            restored: false,
+            removed: false,
+            failed: true,
+            ...(claimed ? { recoveryPath: claimedPath } : {})
+        };
+    }
+    finally {
+        await fsp.rm(candidatePath, { force: true }).catch(() => undefined);
+    }
+}
+async function restoreClaimedSetupPathIfAbsent(claimedPath, file, claimedState) {
+    try {
+        if (claimedState?.kind === 'regular') {
+            await fsp.link(claimedPath, file);
+        }
+        else if (claimedState?.kind === 'symlink') {
+            await fsp.symlink(await fsp.readlink(claimedPath), file);
+        }
+        else {
+            return false;
+        }
+        await fsp.unlink(claimedPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function capturedSetupFileHash(file) {
+    if (file.kind !== 'regular')
+        return 'missing';
+    return await sha256Text(Buffer.from(file.bytes_base64, 'base64').toString('utf8'));
 }
 function profileFilesForDrift(home, shellProfile) {
     const targets = {

package/dist/cli/install-helpers-install-support.js

@@ -15,7 +15,7 @@ import { reconcileCodexAppUpgradeProcesses } from '../core/codex-app.js';
 import { restartCodexApp } from '../core/codex-app/codex-app-restart.js';
 import { cleanupMacLaunchSecretEnvironment } from '../core/codex-app/menubar/index.js';
 import { recordCodexLbHealthEvent } from '../core/codex-lb-circuit.js';
-import { loadCodexLbEnv, writeCodexLbKeychain, codexLbMetadataPath } from '../core/codex-lb/codex-lb-env.js';
+import { loadCodexLbEnv, codexLbMetadataPath } from '../core/codex-lb/codex-lb-env.js';
 import { codexLbToolCatalogPath, ensureCodexLbToolCatalog } from '../core/codex-lb/codex-lb-tool-catalog.js';
 import { codexLbToolOutputRecoveryNotChecked, codexLbToolOutputRecoveryNotSelected, codexLbToolOutputRecoveryOverrideAcknowledged, probeCodexLbToolOutputRecovery } from '../core/codex-lb/codex-lb-tool-output-recovery.js';
 import { GLM_CODEX_CONFIG_PROFILE_ID, GLM_CODEX_CONFIG_PROVIDER_ID, GLM_CODEX_CONFIG_REASONING_PROFILES, GLM_52_OPENROUTER_MODEL } from '../core/codex-app/openrouter-provider.js';