sidekick-shared 0.27.6 → 0.28.1

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;
@@ -49,6 +52,8 @@ 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"));
@@ -64,6 +69,23 @@ 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');
 }
@@ -159,3 +181,48 @@ 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

@@ -5,7 +5,7 @@ import { type SwitchAccountOptions, type SwitchAccountResult } from './accountSw
 import { type ProviderSyncReport } from './accountSyncTypes';
 import { type AccountConsumerScan } from './processDetection';
 import { type CodexAuthSnapshot } from './codexCredentialStore';
-export { getCodexProfilesDir, getCodexProfileHome, getSystemCodexHome, getCodexCredentialStoreMode, } from './codexPaths';
+export { getCodexProfilesDir, getCodexProfileHome, getSystemCodexHome, getCodexCredentialStoreMode, getCodexMonitoringHomes, resolveSidekickCodexHome, getCodexExecutionEnv, } from './codexPaths';
 export type { CodexCredentialStoreMode } from './codexPaths';
 export interface CodexAccountManagerResult extends AccountManagerResult {
     needsLogin?: boolean;
@@ -13,7 +13,6 @@ 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[];
 /** 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;
@@ -39,7 +38,6 @@ export declare function isCodexProfileAuthenticated(codexHome: string): boolean;
 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
@@ -56,7 +54,6 @@ export declare function resolveSidekickCodexHome(): string;
 export declare function resolveActiveCodexAccount(options?: {
     selfHeal?: boolean;
 }): ResolvedActiveAccount;
-export declare function getCodexExecutionEnv(baseEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 /** Legacy callers can import current; explicit sign-in passes importCurrent: false. */
 export declare function prepareCodexAccount(label: string, options?: {
     importCurrent?: boolean;

package/dist/codexProfiles.js

@@ -33,8 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CODEX_KEYRING_FIX_HINT = exports.getCodexCredentialStoreMode = exports.getSystemCodexHome = exports.getCodexProfileHome = exports.getCodexProfilesDir = void 0;
-exports.getCodexMonitoringHomes = getCodexMonitoringHomes;
+exports.CODEX_KEYRING_FIX_HINT = exports.getCodexExecutionEnv = exports.resolveSidekickCodexHome = exports.getCodexMonitoringHomes = exports.getCodexCredentialStoreMode = exports.getSystemCodexHome = exports.getCodexProfileHome = exports.getCodexProfilesDir = void 0;
 exports.readStoredCodexAccount = readStoredCodexAccount;
 exports.isLiveCodexProfile = isLiveCodexProfile;
 exports.storeCodexProfileAuthUnlocked = storeCodexProfileAuthUnlocked;
@@ -48,9 +47,7 @@ exports.isCodexProfileAuthenticated = isCodexProfileAuthenticated;
 exports.isCodexProfileAuthenticatedAsync = isCodexProfileAuthenticatedAsync;
 exports.listCodexAccounts = listCodexAccounts;
 exports.getActiveCodexAccount = getActiveCodexAccount;
-exports.resolveSidekickCodexHome = resolveSidekickCodexHome;
 exports.resolveActiveCodexAccount = resolveActiveCodexAccount;
-exports.getCodexExecutionEnv = getCodexExecutionEnv;
 exports.prepareCodexAccount = prepareCodexAccount;
 exports.prepareCodexAccountAsync = prepareCodexAccountAsync;
 exports.discardCodexLogin = discardCodexLogin;
@@ -97,34 +94,10 @@ Object.defineProperty(exports, "getCodexProfilesDir", { enumerable: true, get: f
 Object.defineProperty(exports, "getCodexProfileHome", { enumerable: true, get: function () { return codexPaths_2.getCodexProfileHome; } });
 Object.defineProperty(exports, "getSystemCodexHome", { enumerable: true, get: function () { return codexPaths_2.getSystemCodexHome; } });
 Object.defineProperty(exports, "getCodexCredentialStoreMode", { enumerable: true, get: function () { return codexPaths_2.getCodexCredentialStoreMode; } });
+Object.defineProperty(exports, "getCodexMonitoringHomes", { enumerable: true, get: function () { return codexPaths_2.getCodexMonitoringHomes; } });
+Object.defineProperty(exports, "resolveSidekickCodexHome", { enumerable: true, get: function () { return codexPaths_2.resolveSidekickCodexHome; } });
+Object.defineProperty(exports, "getCodexExecutionEnv", { enumerable: true, get: function () { return codexPaths_2.getCodexExecutionEnv; } });
 exports.CODEX_KEYRING_FIX_HINT = 'Set `cli_auth_credentials_store = "file"` in ~/.codex/config.toml and run `codex login` again.';
-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 = (0, codexPaths_1.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 = [(0, codexPaths_1.getDefaultSystemCodexHome)()];
-    for (const profile of listCodexAccounts()) {
-        const profileHome = (0, codexPaths_1.getCodexProfileHome)(profile.id);
-        if (fs.existsSync(path.join(profileHome, 'sessions'))) {
-            homes.push(profileHome);
-        }
-    }
-    return dedupePaths(homes);
-}
 function readPendingProfile(profileId) {
     try {
         return JSON.parse(fs.readFileSync((0, codexPaths_1.getCodexLoginStatePath)(profileId), 'utf8'));
@@ -406,11 +379,6 @@ function listCodexAccounts() {
 function getActiveCodexAccount() {
     return (0, accountRegistry_1.getActiveSavedAccount)('codex');
 }
-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 (0, codexPaths_1.getSystemCodexHome)();
-}
 function profileIdentity(profile) {
     return {
         email: profile.email ?? profile.metadata?.email,
@@ -432,7 +400,7 @@ function profileIdentity(profile) {
  */
 function resolveActiveCodexAccount(options = {}) {
     const selfHeal = options.selfHeal ?? true;
-    const identity = (0, codexAuth_1.readAuthIdentityFromRaw)((0, codexPaths_1.readFileOrNull)(path.join(resolveSidekickCodexHome(), 'auth.json')));
+    const identity = (0, codexAuth_1.readAuthIdentityFromRaw)((0, codexPaths_1.readFileOrNull)(path.join((0, codexPaths_1.resolveSidekickCodexHome)(), 'auth.json')));
     if (identity && (identity.email || identity.workspaceId)) {
         const match = findProfileForIdentity(identity);
         if (match) {
@@ -471,12 +439,6 @@ function resolveActiveCodexAccount(options = {}) {
     }
     return { source: 'none' };
 }
-function getCodexExecutionEnv(baseEnv = process.env) {
-    return {
-        ...baseEnv,
-        CODEX_HOME: resolveSidekickCodexHome(),
-    };
-}
 // ── Prepare / finalize (add account) ─────────────────────────────────────
 function keyringRefusal(mode) {
     return {

package/dist/doctor.js

@@ -37,7 +37,6 @@ exports.getSessionDiagnostics = getSessionDiagnostics;
 exports.runDoctor = runDoctor;
 exports.formatHealthReport = formatHealthReport;
 const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const accountStatus_1 = require("./accountStatus");
 const paths_1 = require("./paths");
@@ -48,11 +47,12 @@ const openCode_1 = require("./providers/openCode");
 const factory_1 = require("./providers/factory");
 const detect_1 = require("./providers/detect");
 const openCodeDatabase_1 = require("./providers/openCodeDatabase");
+const claudePaths_1 = require("./claudePaths");
 /** Collects the Claude Code path-resolution detail used by both host surfaces. */
 function getSessionDiagnostics(workspacePath) {
     const encodedPath = (0, sessionPathResolver_1.encodeWorkspacePath)(workspacePath);
     const expectedSessionDir = (0, sessionPathResolver_1.getSessionDirectory)(workspacePath);
-    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+    const projectsDir = (0, claudePaths_1.getClaudeProjectsDir)();
     let existingProjectDirs = [];
     let expectedDirExists = false;
     try {

package/dist/esm/accountChangeSignal.js

@@ -0,0 +1,15 @@
+const listeners = new Set();
+export function _onRawAccountsChanged(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+export function _emitAccountsChanged(reason) {
+    for (const listener of listeners) {
+        try {
+            listener(reason);
+        }
+        catch {
+            // Account notifications are observational and cannot break mutations.
+        }
+    }
+}

package/dist/esm/accountChanges.js

@@ -0,0 +1,152 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { _emitAccountsChanged, _onRawAccountsChanged, } from './accountChangeSignal';
+import { getActiveAccountStatus } from './accountStatus';
+import { getAccountsDir } from './accountRegistry';
+import { syncLiveAccountStateSync } from './accountSync';
+import { getLiveClaudeHome } from './claudeProfiles';
+import { getSystemCodexHome } from './codexPaths';
+const listeners = new Set();
+let watchers = [];
+let pollTimer;
+let stopRawListener;
+let lastFingerprint;
+let debounceTimer;
+const DEFAULT_POLL_INTERVAL_MS = 30_000;
+let activePollIntervalMs = DEFAULT_POLL_INTERVAL_MS;
+/**
+ * Observe login, logout, and active-account switches. Local Sidekick mutations
+ * signal immediately; filesystem watchers cover external CLIs; a low-frequency
+ * catch-up poll protects network mounts and watcher-hostile filesystems.
+ */
+export function onAccountsChanged(listener, options = {}) {
+    listeners.add(listener);
+    // The fastest interval any live subscriber asked for wins; a later, faster
+    // subscriber restarts the timer rather than being silently ignored.
+    const requestedPollMs = Math.max(1_000, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+    if (!stopRawListener) {
+        activePollIntervalMs = requestedPollMs;
+        ensureMonitoring();
+    }
+    else if (requestedPollMs < activePollIntervalMs) {
+        activePollIntervalMs = requestedPollMs;
+        restartPollTimer();
+    }
+    if (options.emitCurrent)
+        emitIfChanged('poll', true, listener);
+    return {
+        dispose: () => {
+            listeners.delete(listener);
+            if (listeners.size === 0)
+                stopMonitoring();
+        },
+    };
+}
+function ensureMonitoring() {
+    if (stopRawListener)
+        return;
+    lastFingerprint = fingerprint(getActiveAccountStatus());
+    stopRawListener = _onRawAccountsChanged((reason) => scheduleCheck(reason));
+    for (const target of watchTargets()) {
+        try {
+            const watcher = fs.watch(target, { persistent: false }, () => {
+                scheduleCheck('filesystem');
+            });
+            watcher.on('error', () => {
+                watchers = watchers.filter((candidate) => candidate !== watcher);
+                try {
+                    watcher.close();
+                }
+                catch {
+                    // The catch-up poll remains active.
+                }
+            });
+            watchers.push(watcher);
+        }
+        catch {
+            // Missing/unwatchable directories are covered by the catch-up poll.
+        }
+    }
+    startPollTimer();
+}
+function startPollTimer() {
+    pollTimer = setInterval(() => emitIfChanged('poll'), activePollIntervalMs);
+    pollTimer.unref?.();
+}
+function restartPollTimer() {
+    if (pollTimer)
+        clearInterval(pollTimer);
+    startPollTimer();
+}
+function stopMonitoring() {
+    stopRawListener?.();
+    stopRawListener = undefined;
+    for (const watcher of watchers)
+        watcher.close();
+    watchers = [];
+    if (pollTimer)
+        clearInterval(pollTimer);
+    pollTimer = undefined;
+    if (debounceTimer)
+        clearTimeout(debounceTimer);
+    debounceTimer = undefined;
+    lastFingerprint = undefined;
+    activePollIntervalMs = DEFAULT_POLL_INTERVAL_MS;
+}
+function watchTargets() {
+    return Array.from(new Set([
+        getAccountsDir(),
+        getLiveClaudeHome(),
+        path.join(os.homedir(), '.claude'),
+        getSystemCodexHome(),
+    ]));
+}
+function scheduleCheck(reason) {
+    if (debounceTimer)
+        clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+        debounceTimer = undefined;
+        // Never force: watch targets include ~/.claude and the Codex home, whose
+        // history files churn on every prompt. Only a real status change may wake
+        // subscribers, or dormant quota pollers would poll on unrelated writes.
+        emitIfChanged(reason);
+    }, 25);
+    debounceTimer.unref?.();
+}
+function emitIfChanged(reason, force = false, singleListener) {
+    // External CLIs write the live homes directly: fold their logins into the
+    // saved profiles before reporting status, so a native `claude /login` is
+    // registered and its rotated tokens are backed up without a host round-trip.
+    // `local` signals come from our own registry writes and need no sync.
+    if (reason === 'filesystem' || reason === 'poll') {
+        try {
+            syncLiveAccountStateSync({ reason: reason === 'poll' ? 'poll' : 'watch' });
+        }
+        catch {
+            // Sync problems surface through the health model, never through the watcher.
+        }
+    }
+    const status = getActiveAccountStatus();
+    const nextFingerprint = fingerprint(status);
+    if (!force && nextFingerprint === lastFingerprint)
+        return;
+    lastFingerprint = nextFingerprint;
+    const event = { reason, status };
+    const targets = singleListener ? [singleListener] : [...listeners];
+    for (const listener of targets) {
+        try {
+            listener(event);
+        }
+        catch {
+            // A host callback cannot stop monitoring.
+        }
+    }
+}
+function fingerprint(status) {
+    return JSON.stringify(status);
+}
+/** Internal bridge for account mutations outside the registry module. */
+export function _notifyAccountsChanged() {
+    _emitAccountsChanged('local');
+}