sidekick-shared 0.27.5 → 0.28.0

package/dist/codexPaths.d.ts

@@ -2,16 +2,23 @@ export declare function getDefaultSystemCodexHome(): string;
 export declare function getExplicitCodexHome(): string | null;
 /** The home the `codex` CLI reads for this process: `CODEX_HOME` or `~/.codex`. */
 export declare function getSystemCodexHome(): string;
+export declare function resolveSidekickCodexHome(): string;
+/**
+ * The environment for spawning `codex`: `baseEnv` with `CODEX_HOME` set to the
+ * live home. A non-blank `CODEX_HOME` already in `baseEnv` is kept, so a caller
+ * that points one child at its own home does not have it overwritten.
+ */
+export declare function getCodexExecutionEnv(baseEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 export declare function getCodexProfilesDir(): string;
 export declare function getCodexProfileDir(profileId: string): string;
 export declare function getCodexProfileHome(profileId: string): string;
 export declare function getCodexProfileStatePath(profileId: string): string;
 export declare function ensureCodexProfileDirs(profileId: string): void;
 export declare function readFileOrNull(filePath: string): string | null;
-export type CodexCredentialStoreMode = 'file' | 'keyring' | 'auto' | 'ephemeral' | 'unknown';
+export type CodexCredentialStoreMode = 'file' | 'keyring' | 'auto' | 'ephemeral' | 'unknown' | 'unreadable';
 /**
  * How the `codex` CLI persists credentials for a home, from its `config.toml`.
- * `unknown` means the key is absent (older CLIs: file; newer CLIs: auto).
+ * `unknown` means the key is absent (Codex defaults to file storage).
  */
 export declare function getCodexCredentialStoreMode(codexHome?: string): CodexCredentialStoreMode;
 /**
@@ -19,3 +26,24 @@ export declare function getCodexCredentialStoreMode(codexHome?: string): CodexCr
  * keyring entry sidekick could never swap. Adds the key when absent.
  */
 export declare function forceFileCredentialStore(configToml: string): string;
+export declare function getCodexBackupPath(id: string, legacy?: boolean): string;
+export declare function getCodexLoginsDir(): string;
+export declare function getCodexLoginDir(id: string): string;
+/** Legacy pending profiles remain readable until finalized or discarded. */
+export declare function getCodexLoginHome(id: string): string;
+export declare function getCodexLoginStatePath(id: string): string;
+export declare function getCodexMonitoringHomes(): string[];
+/** Where Codex writes live rollouts, below each home. */
+export declare const CODEX_SESSIONS_SUBDIR = "sessions";
+/** Where Codex moves a rollout when its thread is archived, below each home. */
+export declare const CODEX_ARCHIVED_SESSIONS_SUBDIR = "archived_sessions";
+export interface CodexSessionsDirsOptions {
+    /** Also list each home's `archived_sessions` directory when it exists (default true). */
+    includeArchived?: boolean;
+}
+/**
+ * Every directory that may hold Codex rollouts: each home's `sessions`, then
+ * each home's `archived_sessions` that exists. Live directories come first so
+ * callers that pick one directory pick a live one.
+ */
+export declare function getCodexSessionsDirs(homes?: string[], options?: CodexSessionsDirsOptions): string[];

package/dist/codexPaths.js

@@ -33,9 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODEX_ARCHIVED_SESSIONS_SUBDIR = exports.CODEX_SESSIONS_SUBDIR = void 0;
 exports.getDefaultSystemCodexHome = getDefaultSystemCodexHome;
 exports.getExplicitCodexHome = getExplicitCodexHome;
 exports.getSystemCodexHome = getSystemCodexHome;
+exports.resolveSidekickCodexHome = resolveSidekickCodexHome;
+exports.getCodexExecutionEnv = getCodexExecutionEnv;
 exports.getCodexProfilesDir = getCodexProfilesDir;
 exports.getCodexProfileDir = getCodexProfileDir;
 exports.getCodexProfileHome = getCodexProfileHome;
@@ -44,6 +47,13 @@ exports.ensureCodexProfileDirs = ensureCodexProfileDirs;
 exports.readFileOrNull = readFileOrNull;
 exports.getCodexCredentialStoreMode = getCodexCredentialStoreMode;
 exports.forceFileCredentialStore = forceFileCredentialStore;
+exports.getCodexBackupPath = getCodexBackupPath;
+exports.getCodexLoginsDir = getCodexLoginsDir;
+exports.getCodexLoginDir = getCodexLoginDir;
+exports.getCodexLoginHome = getCodexLoginHome;
+exports.getCodexLoginStatePath = getCodexLoginStatePath;
+exports.getCodexMonitoringHomes = getCodexMonitoringHomes;
+exports.getCodexSessionsDirs = getCodexSessionsDirs;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -59,10 +69,32 @@ function getExplicitCodexHome() {
 function getSystemCodexHome() {
     return getExplicitCodexHome() ?? getDefaultSystemCodexHome();
 }
+function resolveSidekickCodexHome() {
+    // Account switching swaps auth.json inside the system home, so the system
+    // home (or an explicit CODEX_HOME) is always the single live home.
+    return getSystemCodexHome();
+}
+/**
+ * The environment for spawning `codex`: `baseEnv` with `CODEX_HOME` set to the
+ * live home. A non-blank `CODEX_HOME` already in `baseEnv` is kept, so a caller
+ * that points one child at its own home does not have it overwritten.
+ */
+function getCodexExecutionEnv(baseEnv = process.env) {
+    const requested = baseEnv.CODEX_HOME?.trim();
+    return {
+        ...baseEnv,
+        CODEX_HOME: requested ? requested : resolveSidekickCodexHome(),
+    };
+}
 function getCodexProfilesDir() {
     return path.join((0, accountRegistry_1.getAccountsDir)(), 'codex', 'profiles');
 }
+function assertCodexAccountId(id) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(id))
+        throw new Error('Invalid Codex account id.');
+}
 function getCodexProfileDir(profileId) {
+    assertCodexAccountId(profileId);
     return path.join(getCodexProfilesDir(), profileId);
 }
 function getCodexProfileHome(profileId) {
@@ -82,26 +114,40 @@ function readFileOrNull(filePath) {
         return null;
     }
 }
-const STORE_MODE_PATTERN = /^\s*cli_auth_credentials_store\s*=\s*"([a-z]+)"/m;
+const STORE_MODE_PATTERN = /^[ \t]*cli_auth_credentials_store[ \t]*=[ \t]*["']([a-z]+)["']/m;
 /**
  * How the `codex` CLI persists credentials for a home, from its `config.toml`.
- * `unknown` means the key is absent (older CLIs: file; newer CLIs: auto).
+ * `unknown` means the key is absent (Codex defaults to file storage).
  */
 function getCodexCredentialStoreMode(codexHome = getSystemCodexHome()) {
-    const config = readFileOrNull(path.join(codexHome, 'config.toml'));
-    const match = config?.match(STORE_MODE_PATTERN);
+    let config;
+    try {
+        config = fs.readFileSync(path.join(codexHome, 'config.toml'), 'utf8');
+    }
+    catch (error) {
+        return error.code === 'ENOENT' ? 'unknown' : 'unreadable';
+    }
+    const topLevel = config.split(/^[ \t]*\[/m, 1)[0];
+    const match = topLevel.match(STORE_MODE_PATTERN);
+    if (!match && /^[ \t]*cli_auth_credentials_store\s*=/m.test(topLevel))
+        return 'unreadable';
     const value = match?.[1];
     return value === 'file' || value === 'keyring' || value === 'auto' || value === 'ephemeral'
         ? value
-        : 'unknown';
+        : value === undefined
+            ? 'unknown'
+            : 'unreadable';
 }
 /**
  * Rewrite a `config.toml` so an isolated login writes `auth.json` instead of a
  * keyring entry sidekick could never swap. Adds the key when absent.
  */
 function forceFileCredentialStore(configToml) {
-    if (STORE_MODE_PATTERN.test(configToml)) {
-        return configToml.replace(STORE_MODE_PATTERN, 'cli_auth_credentials_store = "file"');
+    const firstHeader = configToml.search(/^[ \t]*\[/m);
+    const header = firstHeader < 0 ? configToml : configToml.slice(0, firstHeader);
+    if (STORE_MODE_PATTERN.test(header)) {
+        return (header.replace(STORE_MODE_PATTERN, 'cli_auth_credentials_store = "file"') +
+            (firstHeader < 0 ? '' : configToml.slice(firstHeader)));
     }
     const line = 'cli_auth_credentials_store = "file"';
     const trimmed = configToml.replace(/\s*$/, '');
@@ -115,3 +161,68 @@ function forceFileCredentialStore(configToml) {
     const head = trimmed.slice(0, firstTable).replace(/\s*$/, '');
     return `${head ? `${head}\n` : ''}${line}\n\n${trimmed.slice(firstTable).replace(/^\s*/, '')}\n`;
 }
+function getCodexBackupPath(id, legacy = false) {
+    assertCodexAccountId(id);
+    return path.join((0, accountRegistry_1.getAccountsDir)(), 'codex', 'backups', `${id}.${legacy ? 'credentials' : 'auth'}.json`);
+}
+function getCodexLoginsDir() {
+    return path.join((0, accountRegistry_1.getAccountsDir)(), 'codex', 'logins');
+}
+function getCodexLoginDir(id) {
+    assertCodexAccountId(id);
+    return path.join(getCodexLoginsDir(), id);
+}
+/** Legacy pending profiles remain readable until finalized or discarded. */
+function getCodexLoginHome(id) {
+    const dir = getCodexLoginDir(id);
+    return fs.existsSync(dir) ? path.join(dir, 'codex-home') : getCodexProfileHome(id);
+}
+function getCodexLoginStatePath(id) {
+    const dir = getCodexLoginDir(id);
+    return fs.existsSync(dir) ? path.join(dir, 'profile.json') : getCodexProfileStatePath(id);
+}
+function dedupePaths(paths) {
+    const seen = new Set();
+    const unique = [];
+    for (const candidate of paths) {
+        const normalized = path.resolve(candidate);
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        unique.push(candidate);
+    }
+    return unique;
+}
+function getCodexMonitoringHomes() {
+    const explicitHome = getExplicitCodexHome();
+    if (explicitHome)
+        return [explicitHome];
+    // The system home is the single live home; profile homes only matter for
+    // sessions recorded back when they doubled as live CODEX_HOMEs.
+    const homes = [getDefaultSystemCodexHome()];
+    for (const profile of (0, accountRegistry_1.listSavedAccountProfiles)('codex')) {
+        const profileHome = getCodexProfileHome(profile.id);
+        if (fs.existsSync(path.join(profileHome, 'sessions'))) {
+            homes.push(profileHome);
+        }
+    }
+    return dedupePaths(homes);
+}
+/** Where Codex writes live rollouts, below each home. */
+exports.CODEX_SESSIONS_SUBDIR = 'sessions';
+/** Where Codex moves a rollout when its thread is archived, below each home. */
+exports.CODEX_ARCHIVED_SESSIONS_SUBDIR = 'archived_sessions';
+/**
+ * Every directory that may hold Codex rollouts: each home's `sessions`, then
+ * each home's `archived_sessions` that exists. Live directories come first so
+ * callers that pick one directory pick a live one.
+ */
+function getCodexSessionsDirs(homes = getCodexMonitoringHomes(), options = {}) {
+    const live = homes.map((home) => path.join(home, exports.CODEX_SESSIONS_SUBDIR));
+    if (options.includeArchived === false)
+        return live;
+    const archived = homes
+        .map((home) => path.join(home, exports.CODEX_ARCHIVED_SESSIONS_SUBDIR))
+        .filter((dir) => fs.existsSync(dir));
+    return [...live, ...archived];
+}

package/dist/codexProfiles.d.ts

@@ -3,7 +3,9 @@ import type { AccountManagerResult } from './accounts';
 import { type AccountHealthSource } from './accountHealth';
 import { type SwitchAccountOptions, type SwitchAccountResult } from './accountSwitch';
 import { type ProviderSyncReport } from './accountSyncTypes';
-export { getCodexProfilesDir, getCodexProfileHome, getSystemCodexHome, getCodexCredentialStoreMode, } from './codexPaths';
+import { type AccountConsumerScan } from './processDetection';
+import { type CodexAuthSnapshot } from './codexCredentialStore';
+export { getCodexProfilesDir, getCodexProfileHome, getSystemCodexHome, getCodexCredentialStoreMode, getCodexMonitoringHomes, resolveSidekickCodexHome, getCodexExecutionEnv, } from './codexPaths';
 export type { CodexCredentialStoreMode } from './codexPaths';
 export interface CodexAccountManagerResult extends AccountManagerResult {
     needsLogin?: boolean;
@@ -11,12 +13,11 @@ export interface CodexAccountManagerResult extends AccountManagerResult {
     codexHome?: string;
 }
 export declare const CODEX_KEYRING_FIX_HINT = "Set `cli_auth_credentials_store = \"file\"` in ~/.codex/config.toml and run `codex login` again.";
-export declare function getCodexMonitoringHomes(): string[];
-/**
- * The single chokepoint for storing a Codex credential in a profile: the raw
- * `auth.json` bytes (never re-serialized), the legacy `.credentials.json`
- * when present, and the secret-free health sidecar.
- */
+/** Read the freshest saved login without creating a CLI-usable copy. */
+export declare function readStoredCodexAccount(profileId: string): CodexAuthSnapshot | null;
+export declare function isLiveCodexProfile(profile: SavedAccountProfile): boolean;
+/** Caller holds the swap lock. Live-account credentials only enter private storage. */
+export declare function storeCodexProfileAuthUnlocked(profileId: string, authRaw: string | null, legacyRaw: string | null, source: AccountHealthSource): void;
 export declare function storeCodexProfileAuth(profileId: string, authRaw: string | null, legacyRaw: string | null, source: AccountHealthSource): void;
 interface CodexLoginStatus {
     loggedIn: boolean;
@@ -34,11 +35,9 @@ export declare function readCodexAccountMetadata(codexHome: string): AccountIden
 /** {@link readCodexAccountMetadata} without blocking the event loop on the CLI probe. */
 export declare function readCodexAccountMetadataAsync(codexHome: string): Promise<AccountIdentityMetadata>;
 export declare function isCodexProfileAuthenticated(codexHome: string): boolean;
-/** {@link isCodexProfileAuthenticated} without blocking the event loop on the CLI probe. */
 export declare function isCodexProfileAuthenticatedAsync(codexHome: string): Promise<boolean>;
 export declare function listCodexAccounts(): SavedAccountProfile[];
 export declare function getActiveCodexAccount(): SavedAccountProfile | null;
-export declare function resolveSidekickCodexHome(): string;
 /**
  * Resolves the *currently logged-in* Codex account for display, preferring the
  * live `auth.json` identity over the saved registry pointer (which only sidekick's
@@ -55,14 +54,18 @@ export declare function resolveSidekickCodexHome(): string;
 export declare function resolveActiveCodexAccount(options?: {
     selfHeal?: boolean;
 }): ResolvedActiveAccount;
-export declare function getCodexExecutionEnv(baseEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-export declare function prepareCodexAccount(label: string): CodexAccountManagerResult;
-/** {@link prepareCodexAccount} without blocking the event loop on CLI probes. */
-export declare function prepareCodexAccountAsync(label: string): Promise<CodexAccountManagerResult>;
+/** Legacy callers can import current; explicit sign-in passes importCurrent: false. */
+export declare function prepareCodexAccount(label: string, options?: {
+    importCurrent?: boolean;
+}): CodexAccountManagerResult;
+export declare function prepareCodexAccountAsync(label: string, options?: {
+    importCurrent?: boolean;
+}): Promise<CodexAccountManagerResult>;
+/** Removes only a pending login, never a registered canonical profile. */
+export declare function discardCodexLogin(id: string): void;
 export declare function finalizeCodexAccount(profileId: string, opts?: {
     activate?: boolean;
 }): CodexAccountManagerResult;
-/** {@link finalizeCodexAccount} without blocking the event loop on CLI probes. */
 export declare function finalizeCodexAccountAsync(profileId: string, opts?: {
     activate?: boolean;
 }): Promise<CodexAccountManagerResult>;
@@ -75,33 +78,33 @@ export declare function finalizeCodexAccountAsync(profileId: string, opts?: {
  * child process while holding it.
  */
 export declare function withCodexAuthSwapLock<T>(operation: () => T): T;
-/**
- * Merge duplicate Codex profiles (same workspace, else same email). The oldest
- * profile keeps its id and label, receives the freshest `auth.json` and the
- * quota snapshot, and the active pointer; losers are stashed, never deleted.
- * Returns the removed ids. Caller holds the swap lock.
- */
-export declare function dedupeCodexProfiles(): string[];
-/**
- * Fold the live `auth.json` into the saved profiles: register an unknown login
- * (label = email), refresh the matching profile's backup when the live file is
- * newer, and re-point the active pointer at it. Caller holds the swap lock.
- * Never throws; problems land in `warnings`.
- */
+/** Merge owned profiles only after preserving their newest login in a verified backup. */
+export declare function dedupeCodexProfiles(scan?: AccountConsumerScan): string[];
+export declare function hasPendingCodexRepair(): boolean;
+/** No subprocesses inside this function: hosts resolve process scans before taking the lock. */
 export declare function syncCodexLiveStateUnlocked(source?: AccountHealthSource, probes?: {
+    scan?: AccountConsumerScan;
     systemKeyringLoggedIn?: boolean;
 }): ProviderSyncReport;
-/** {@link syncCodexLiveStateUnlocked} under the swap lock. */
 export declare function syncCodexLiveState(source?: AccountHealthSource): ProviderSyncReport;
-/**
- * Remove isolated login homes that never authenticated once they are older
- * than `olderThanMs`. Returns the removed profile ids.
- */
-export declare function cleanupAbandonedCodexLogins(olderThanMs?: number, now?: number): string[];
+export declare function syncCodexLiveStateAsync(source?: AccountHealthSource): Promise<ProviderSyncReport>;
+/** Only abandoned Sidekick-owned login homes; authenticated copies are preserved privately first. */
+export declare function cleanupAbandonedCodexLogins(olderThanMs?: number, now?: number, scan?: AccountConsumerScan): string[];
 export declare function switchToCodexAccount(profileId: string, options?: SwitchAccountOptions): SwitchAccountResult;
-/** {@link switchToCodexAccount} without blocking the event loop on CLI probes. */
 export declare function switchToCodexAccountAsync(profileId: string, options?: SwitchAccountOptions): Promise<SwitchAccountResult>;
+/** Legacy migration entry points now use the same guarded reconciliation as ordinary sync. */
 export declare function reconcileCodexAuthState(): void;
-/** {@link reconcileCodexAuthState} without blocking the event loop on CLI probes. */
 export declare function reconcileCodexAuthStateAsync(): Promise<void>;
+export declare function getCodexKeepAliveBlocker(id: string): string | null;
+export declare function beginCodexKeepAlive(id: string, leaseMs: number): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function finishCodexKeepAlive(id: string): void;
+export declare function restoreCodexProfileFromBackup(id: string, options?: {
+    restore?: boolean;
+}): 'restored' | 'present' | 'live' | 'none';
 export declare function removeCodexAccount(profileId: string): AccountManagerResult;
+export declare function cleanupAbandonedCodexLoginsAsync(olderThanMs?: number, now?: number): Promise<string[]>;