sidekick-shared 0.24.4 → 0.25.0

package/dist/accountChanges.js

@@ -0,0 +1,151 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onAccountsChanged = onAccountsChanged;
+exports._notifyAccountsChanged = _notifyAccountsChanged;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const accountChangeSignal_1 = require("./accountChangeSignal");
+const accountStatus_1 = require("./accountStatus");
+const accountRegistry_1 = require("./accountRegistry");
+const codexProfiles_1 = require("./codexProfiles");
+const listeners = new Set();
+let watchers = [];
+let pollTimer;
+let stopRawListener;
+let lastFingerprint;
+let debounceTimer;
+let activePollIntervalMs = 30_000;
+/**
+ * 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.
+ */
+function onAccountsChanged(listener, options = {}) {
+    listeners.add(listener);
+    activePollIntervalMs = Math.max(1_000, options.pollIntervalMs ?? activePollIntervalMs);
+    ensureMonitoring();
+    if (options.emitCurrent)
+        emitIfChanged('poll', true, listener);
+    return {
+        dispose: () => {
+            listeners.delete(listener);
+            if (listeners.size === 0)
+                stopMonitoring();
+        },
+    };
+}
+function ensureMonitoring() {
+    if (stopRawListener)
+        return;
+    lastFingerprint = fingerprint((0, accountStatus_1.getActiveAccountStatus)());
+    stopRawListener = (0, accountChangeSignal_1._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.
+        }
+    }
+    pollTimer = setInterval(() => emitIfChanged('poll'), activePollIntervalMs);
+    pollTimer.unref?.();
+}
+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;
+}
+function watchTargets() {
+    return Array.from(new Set([(0, accountRegistry_1.getAccountsDir)(), path.join(os.homedir(), '.claude'), (0, codexProfiles_1.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) {
+    const status = (0, accountStatus_1.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. */
+function _notifyAccountsChanged() {
+    (0, accountChangeSignal_1._emitAccountsChanged)('local');
+}

package/dist/accountManager.d.ts

@@ -46,7 +46,20 @@ export declare function beginAccountLogin(provider: AccountProviderId, label: st
     loginCommand?: AccountLoginCommand;
 }): BeginAccountLoginResult;
 export declare function getAccountLoginStatus(provider: AccountProviderId, loginId: string): AccountLoginStatus;
+/**
+ * {@link getAccountLoginStatus} without blocking the event loop on the codex
+ * CLI probe. The sync variant blocks up to 4s per call while a codex login is
+ * pending — ruinous for callers that poll it on an interval.
+ */
+export declare function getAccountLoginStatusAsync(provider: AccountProviderId, loginId: string): Promise<AccountLoginStatus>;
 export declare function finalizeAccountLogin(provider: AccountProviderId, loginId: string, opts?: FinalizeAccountLoginOptions): AccountManagerResult;
+/** {@link finalizeAccountLogin} without blocking the event loop on CLI probes. */
+export declare function finalizeAccountLoginAsync(provider: AccountProviderId, loginId: string, opts?: FinalizeAccountLoginOptions): Promise<AccountManagerResult>;
 export declare function spawnAccountLogin(provider: AccountProviderId, label: string, opts?: SpawnAccountLoginOptions): Promise<AccountManagerResult>;
 export declare function switchAccount(provider: AccountProviderId, id: string): AccountManagerResult;
+/**
+ * {@link switchAccount} without blocking the event loop on codex CLI probes.
+ * The Claude path still performs bounded synchronous keychain reads on macOS.
+ */
+export declare function switchAccountAsync(provider: AccountProviderId, id: string): Promise<AccountManagerResult>;
 export declare function listAllAccounts(): ListAllAccountsResult;

package/dist/accountManager.js

@@ -36,15 +36,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveClaudeLoginCommand = resolveClaudeLoginCommand;
 exports.beginAccountLogin = beginAccountLogin;
 exports.getAccountLoginStatus = getAccountLoginStatus;
+exports.getAccountLoginStatusAsync = getAccountLoginStatusAsync;
 exports.finalizeAccountLogin = finalizeAccountLogin;
+exports.finalizeAccountLoginAsync = finalizeAccountLoginAsync;
 exports.spawnAccountLogin = spawnAccountLogin;
 exports.switchAccount = switchAccount;
+exports.switchAccountAsync = switchAccountAsync;
 exports.listAllAccounts = listAllAccounts;
 const child_process_1 = require("child_process");
 const crypto_1 = require("crypto");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const accountRegistry_1 = require("./accountRegistry");
+const atomic_1 = require("./writers/atomic");
 const accounts_1 = require("./accounts");
 const claudeProfiles_1 = require("./claudeProfiles");
 const credentialIO_1 = require("./credentialIO");
@@ -55,25 +59,6 @@ function getClaudeProfileDir(loginId) {
 function getPendingClaudeProfilePath(loginId) {
     return path.join(getClaudeProfileDir(loginId), 'profile.json');
 }
-function atomicWriteJson(filePath, data, mode = 0o600) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
-    const tmp = `${filePath}.tmp`;
-    const json = JSON.stringify(data, null, 2);
-    JSON.parse(json);
-    try {
-        fs.writeFileSync(tmp, json, { encoding: 'utf8', mode });
-        fs.renameSync(tmp, filePath);
-    }
-    catch (err) {
-        try {
-            fs.unlinkSync(tmp);
-        }
-        catch {
-            /* nothing to clean up */
-        }
-        throw err;
-    }
-}
 function readPendingClaudeProfile(loginId) {
     try {
         return JSON.parse(fs.readFileSync(getPendingClaudeProfilePath(loginId), 'utf8'));
@@ -84,7 +69,7 @@ function readPendingClaudeProfile(loginId) {
 }
 function writePendingClaudeProfile(loginId, pending) {
     (0, claudeProfiles_1.ensureClaudeProfileDirs)(loginId);
-    atomicWriteJson(getPendingClaudeProfilePath(loginId), pending);
+    (0, atomic_1.atomicWriteJsonSync)(getPendingClaudeProfilePath(loginId), pending);
 }
 function removePendingClaudeProfile(loginId) {
     try {
@@ -182,6 +167,13 @@ function beginAccountLogin(provider, label, opts = {}) {
         configDir: home,
     };
 }
+function getClaudeAccountLoginStatus(loginId) {
+    const home = (0, claudeProfiles_1.getClaudeProfileHome)(loginId);
+    const identity = (0, claudeProfiles_1.readClaudeProfileIdentity)(home);
+    return (0, claudeProfiles_1.isClaudeProfileAuthenticated)(home)
+        ? { state: 'authenticated', email: identity?.email }
+        : { state: 'pending' };
+}
 function getAccountLoginStatus(provider, loginId) {
     if (provider === 'codex') {
         const codexHome = (0, codexProfiles_1.getCodexProfileHome)(loginId);
@@ -194,16 +186,41 @@ function getAccountLoginStatus(provider, loginId) {
             email: metadata.email,
         };
     }
-    const home = (0, claudeProfiles_1.getClaudeProfileHome)(loginId);
-    const identity = (0, claudeProfiles_1.readClaudeProfileIdentity)(home);
-    return (0, claudeProfiles_1.isClaudeProfileAuthenticated)(home)
-        ? { state: 'authenticated', email: identity?.email }
-        : { state: 'pending' };
+    return getClaudeAccountLoginStatus(loginId);
+}
+/**
+ * {@link getAccountLoginStatus} without blocking the event loop on the codex
+ * CLI probe. The sync variant blocks up to 4s per call while a codex login is
+ * pending — ruinous for callers that poll it on an interval.
+ */
+async function getAccountLoginStatusAsync(provider, loginId) {
+    if (provider === 'codex') {
+        const codexHome = (0, codexProfiles_1.getCodexProfileHome)(loginId);
+        if (!(await (0, codexProfiles_1.isCodexProfileAuthenticatedAsync)(codexHome))) {
+            return { state: 'pending' };
+        }
+        const metadata = await (0, codexProfiles_1.readCodexAccountMetadataAsync)(codexHome);
+        return {
+            state: 'authenticated',
+            email: metadata.email,
+        };
+    }
+    return getClaudeAccountLoginStatus(loginId);
 }
 function finalizeAccountLogin(provider, loginId, opts = {}) {
     if (provider === 'codex') {
         return (0, codexProfiles_1.finalizeCodexAccount)(loginId, opts);
     }
+    return finalizeClaudeAccountLogin(loginId, opts);
+}
+/** {@link finalizeAccountLogin} without blocking the event loop on CLI probes. */
+async function finalizeAccountLoginAsync(provider, loginId, opts = {}) {
+    if (provider === 'codex') {
+        return (0, codexProfiles_1.finalizeCodexAccountAsync)(loginId, opts);
+    }
+    return finalizeClaudeAccountLogin(loginId, opts);
+}
+function finalizeClaudeAccountLogin(loginId, opts = {}) {
     const home = (0, claudeProfiles_1.getClaudeProfileHome)(loginId);
     const identity = (0, claudeProfiles_1.readClaudeProfileIdentity)(home);
     if (!identity) {
@@ -218,8 +235,8 @@ function finalizeAccountLogin(provider, loginId, opts = {}) {
         return { success: false, error: 'Could not read Claude profile config.' };
     }
     const pending = readPendingClaudeProfile(loginId);
-    atomicWriteJson(getClaudeCredentialsBackupPath(identity.uuid), credentials);
-    atomicWriteJson(getClaudeConfigBackupPath(identity.uuid), oauthAccount);
+    (0, atomic_1.atomicWriteJsonSync)(getClaudeCredentialsBackupPath(identity.uuid), credentials);
+    (0, atomic_1.atomicWriteJsonSync)(getClaudeConfigBackupPath(identity.uuid), oauthAccount);
     copyClaudeProfileToCanonicalHome(home, identity.uuid, credentials);
     (0, accountRegistry_1.upsertSavedAccountProfile)({
         id: identity.uuid,
@@ -274,7 +291,7 @@ async function spawnAccountLogin(provider, label, opts = {}) {
     if (!begin.success)
         return { success: false, error: begin.error };
     if (begin.alreadyComplete) {
-        return finalizeAccountLogin(provider, begin.loginId, { activate: opts.activate ?? true });
+        return finalizeAccountLoginAsync(provider, begin.loginId, { activate: opts.activate ?? true });
     }
     if (!begin.command) {
         return { success: false, error: 'Account login command was not prepared.' };
@@ -308,9 +325,11 @@ async function spawnAccountLogin(provider, label, opts = {}) {
             emitStatus(opts, { state: 'failed', error: 'Account login aborted.' });
             return { success: false, error: 'Account login aborted.' };
         }
-        const status = emitStatus(opts, getAccountLoginStatus(provider, begin.loginId));
+        const status = emitStatus(opts, await getAccountLoginStatusAsync(provider, begin.loginId));
         if (status.state === 'authenticated') {
-            return finalizeAccountLogin(provider, begin.loginId, { activate: opts.activate ?? true });
+            return finalizeAccountLoginAsync(provider, begin.loginId, {
+                activate: opts.activate ?? true,
+            });
         }
         if (childExited) {
             if (childState.spawnError) {
@@ -318,9 +337,11 @@ async function spawnAccountLogin(provider, label, opts = {}) {
                 emitStatus(opts, { state: 'failed', error });
                 return { success: false, error };
             }
-            const finalStatus = emitStatus(opts, getAccountLoginStatus(provider, begin.loginId));
+            const finalStatus = emitStatus(opts, await getAccountLoginStatusAsync(provider, begin.loginId));
             if (finalStatus.state === 'authenticated') {
-                return finalizeAccountLogin(provider, begin.loginId, { activate: opts.activate ?? true });
+                return finalizeAccountLoginAsync(provider, begin.loginId, {
+                    activate: opts.activate ?? true,
+                });
             }
             emitStatus(opts, {
                 state: 'failed',
@@ -344,6 +365,13 @@ async function spawnAccountLogin(provider, label, opts = {}) {
 function switchAccount(provider, id) {
     return provider === 'codex' ? (0, codexProfiles_1.switchToCodexAccount)(id) : (0, accounts_1.switchToAccount)(id);
 }
+/**
+ * {@link switchAccount} without blocking the event loop on codex CLI probes.
+ * The Claude path still performs bounded synchronous keychain reads on macOS.
+ */
+async function switchAccountAsync(provider, id) {
+    return provider === 'codex' ? (0, codexProfiles_1.switchToCodexAccountAsync)(id) : (0, accounts_1.switchToAccount)(id);
+}
 function listAllAccounts() {
     return {
         claude: (0, accounts_1.listAccounts)(),

package/dist/accountRegistry.d.ts

@@ -1,4 +1,6 @@
-export type AccountProviderId = 'claude-code' | 'codex';
+import type { AccountProviderId } from './providerIds';
+export { ACCOUNT_PROVIDER_IDS } from './providerIds';
+export type { AccountProviderId } from './providerIds';
 export interface AccountIdentityMetadata {
     email?: string;
     workspaceId?: string;

package/dist/accountRegistry.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACCOUNT_PROVIDER_IDS = void 0;
 exports.getAccountsDir = getAccountsDir;
 exports.readSavedAccountRegistry = readSavedAccountRegistry;
 exports.writeSavedAccountRegistry = writeSavedAccountRegistry;
@@ -45,21 +46,40 @@ exports.removeSavedAccountProfile = removeSavedAccountProfile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const paths_1 = require("./paths");
+const atomic_1 = require("./writers/atomic");
+const accountChangeSignal_1 = require("./accountChangeSignal");
+var providerIds_1 = require("./providerIds");
+Object.defineProperty(exports, "ACCOUNT_PROVIDER_IDS", { enumerable: true, get: function () { return providerIds_1.ACCOUNT_PROVIDER_IDS; } });
 function getAccountsDir() {
     return path.join((0, paths_1.getConfigDir)(), 'accounts');
 }
 function getRegistryPath() {
     return path.join(getAccountsDir(), 'accounts.json');
 }
+function getRegistryLockPath() {
+    return getRegistryPath() + '.lock';
+}
 function ensureAccountsDir() {
     fs.mkdirSync(getAccountsDir(), { recursive: true, mode: 0o700 });
 }
-function atomicWriteJson(filePath, data, mode = 0o600) {
-    const tmp = filePath + '.tmp';
-    const json = JSON.stringify(data, null, 2);
-    JSON.parse(json);
-    fs.writeFileSync(tmp, json, { encoding: 'utf8', mode });
-    fs.renameSync(tmp, filePath);
+function writeRegistryUnlocked(registry) {
+    (0, atomic_1.atomicWriteJsonSync)(getRegistryPath(), normalizeRegistry(registry));
+    (0, accountChangeSignal_1._emitAccountsChanged)('local');
+}
+/**
+ * Serializes registry read-modify-write cycles across processes. Without the
+ * lock, two concurrent mutators (CLI, editor extension, external consumers)
+ * read the same base state and the second write silently drops the first
+ * mutation. Lock ordering: callers that also hold a provider auth-swap lock
+ * take that lock first and this one inside it, never the reverse.
+ */
+function mutateSavedAccountRegistry(mutator) {
+    ensureAccountsDir();
+    return (0, atomic_1.withFileLockSync)(getRegistryLockPath(), () => {
+        const next = mutator(readSavedAccountRegistry() ?? createEmptyRegistry());
+        writeRegistryUnlocked(next);
+        return next;
+    });
 }
 function createEmptyRegistry() {
     return {
@@ -136,7 +156,7 @@ function readSavedAccountRegistry() {
 }
 function writeSavedAccountRegistry(registry) {
     ensureAccountsDir();
-    atomicWriteJson(getRegistryPath(), normalizeRegistry(registry));
+    (0, atomic_1.withFileLockSync)(getRegistryLockPath(), () => writeRegistryUnlocked(registry));
 }
 function listSavedAccountProfiles(providerId) {
     const registry = readSavedAccountRegistry();
@@ -156,44 +176,47 @@ function getActiveSavedAccount(providerId) {
     return (registry.accounts.find((account) => account.providerId === providerId && account.id === activeId) ?? null);
 }
 function upsertSavedAccountProfile(profile) {
-    const registry = readSavedAccountRegistry() ?? createEmptyRegistry();
-    const index = registry.accounts.findIndex((account) => account.providerId === profile.providerId && account.id === profile.id);
-    if (index >= 0) {
-        registry.accounts[index] = profile;
-    }
-    else {
-        registry.accounts.push(profile);
-    }
-    writeSavedAccountRegistry(registry);
-    return registry;
+    return mutateSavedAccountRegistry((registry) => {
+        const index = registry.accounts.findIndex((account) => account.providerId === profile.providerId && account.id === profile.id);
+        if (index >= 0) {
+            registry.accounts[index] = profile;
+        }
+        else {
+            registry.accounts.push(profile);
+        }
+        return registry;
+    });
 }
 function setActiveSavedAccount(providerId, accountId) {
-    const registry = readSavedAccountRegistry() ?? createEmptyRegistry();
-    registry.activeByProvider[providerId] = accountId;
-    writeSavedAccountRegistry(registry);
-    return registry;
+    return mutateSavedAccountRegistry((registry) => {
+        registry.activeByProvider[providerId] = accountId;
+        return registry;
+    });
 }
 function replaceSavedAccountProfiles(providerId, accounts, activeId) {
-    const registry = readSavedAccountRegistry() ?? createEmptyRegistry();
-    registry.accounts = registry.accounts
-        .filter((account) => account.providerId !== providerId)
-        .concat(accounts);
-    registry.activeByProvider[providerId] = activeId;
-    writeSavedAccountRegistry(registry);
-    return registry;
+    return mutateSavedAccountRegistry((registry) => {
+        registry.accounts = registry.accounts
+            .filter((account) => account.providerId !== providerId)
+            .concat(accounts);
+        registry.activeByProvider[providerId] = activeId;
+        return registry;
+    });
 }
 function removeSavedAccountProfile(providerId, accountId) {
-    const registry = readSavedAccountRegistry();
-    if (!registry)
-        return null;
-    const index = registry.accounts.findIndex((account) => account.providerId === providerId && account.id === accountId);
-    if (index === -1)
-        return null;
-    const [removed] = registry.accounts.splice(index, 1);
-    if (registry.activeByProvider[providerId] === accountId) {
-        registry.activeByProvider[providerId] =
-            registry.accounts.find((account) => account.providerId === providerId)?.id ?? null;
-    }
-    writeSavedAccountRegistry(registry);
-    return removed;
+    ensureAccountsDir();
+    return (0, atomic_1.withFileLockSync)(getRegistryLockPath(), () => {
+        const registry = readSavedAccountRegistry();
+        if (!registry)
+            return null;
+        const index = registry.accounts.findIndex((account) => account.providerId === providerId && account.id === accountId);
+        if (index === -1)
+            return null;
+        const [removed] = registry.accounts.splice(index, 1);
+        if (registry.activeByProvider[providerId] === accountId) {
+            registry.activeByProvider[providerId] =
+                registry.accounts.find((account) => account.providerId === providerId)?.id ?? null;
+        }
+        writeRegistryUnlocked(registry);
+        return removed;
+    });
 }

package/dist/accounts.js

@@ -56,6 +56,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const credentialIO_1 = require("./credentialIO");
+const atomic_1 = require("./writers/atomic");
 const accountRegistry_1 = require("./accountRegistry");
 const claudeProfiles_1 = require("./claudeProfiles");
 // ── Paths ────────────────────────────────────────────────────────────────
@@ -91,16 +92,6 @@ function ensureDirs() {
         fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     }
 }
-// ── Atomic file write ────────────────────────────────────────────────────
-function atomicWriteJson(filePath, data, mode = 0o600) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
-    const tmp = filePath + '.tmp';
-    const json = JSON.stringify(data, null, 2);
-    // Validate we can re-parse before writing
-    JSON.parse(json);
-    fs.writeFileSync(tmp, json, { encoding: 'utf8', mode });
-    fs.renameSync(tmp, filePath);
-}
 function readJsonOrNull(filePath) {
     try {
         return JSON.parse(fs.readFileSync(filePath, 'utf8'));
@@ -114,7 +105,7 @@ function readOauthAccountFromConfigPath(filePath) {
     return parsed?.oauthAccount ?? null;
 }
 function writeClaudeProfileConfig(uuid, oauthAccount) {
-    atomicWriteJson(path.join((0, claudeProfiles_1.getClaudeProfileHome)(uuid), '.claude.json'), { oauthAccount });
+    (0, atomic_1.atomicWriteJsonSync)(path.join((0, claudeProfiles_1.getClaudeProfileHome)(uuid), '.claude.json'), { oauthAccount });
 }
 function writeClaudeProfileCredentials(uuid, credentials) {
     (0, credentialIO_1.writeActiveCredentials)(credentials, (0, claudeProfiles_1.getClaudeProfileHome)(uuid));
@@ -162,7 +153,7 @@ function backupCurrentClaudeLiveHome() {
     const originalOauthAccount = readCurrentLiveOauthAccount();
     if (originalCreds) {
         try {
-            atomicWriteJson(path.join(getCredentialsDir(), `${currentActive.uuid}.credentials.json`), originalCreds);
+            (0, atomic_1.atomicWriteJsonSync)(path.join(getCredentialsDir(), `${currentActive.uuid}.credentials.json`), originalCreds);
             writeClaudeProfileCredentials(currentActive.uuid, originalCreds);
         }
         catch {
@@ -171,7 +162,7 @@ function backupCurrentClaudeLiveHome() {
     }
     if (originalOauthAccount) {
         try {
-            atomicWriteJson(path.join(getConfigsDir(), `${currentActive.uuid}.config.json`), originalOauthAccount);
+            (0, atomic_1.atomicWriteJsonSync)(path.join(getConfigsDir(), `${currentActive.uuid}.config.json`), originalOauthAccount);
             writeClaudeProfileConfig(currentActive.uuid, originalOauthAccount);
         }
         catch {
@@ -188,7 +179,7 @@ function mergeOauthAccountIntoLiveConfig(oauthAccount) {
         // File may not exist yet.
     }
     configObj.oauthAccount = oauthAccount;
-    atomicWriteJson(getClaudeConfigPath(), configObj);
+    (0, atomic_1.atomicWriteJsonSync)(getClaudeConfigPath(), configObj);
 }
 // ── Registry operations ──────────────────────────────────────────────────
 function readAccountRegistry() {
@@ -274,8 +265,8 @@ function addCurrentAccount(label) {
     if (existing) {
         if (label !== undefined)
             existing.label = label;
-        atomicWriteJson(path.join(getCredentialsDir(), `${active.uuid}.credentials.json`), credBlob);
-        atomicWriteJson(path.join(getConfigsDir(), `${active.uuid}.config.json`), configBlob);
+        (0, atomic_1.atomicWriteJsonSync)(path.join(getCredentialsDir(), `${active.uuid}.credentials.json`), credBlob);
+        (0, atomic_1.atomicWriteJsonSync)(path.join(getConfigsDir(), `${active.uuid}.config.json`), configBlob);
         try {
             writeClaudeProfileMirror(active.uuid, credBlob, configBlob);
         }
@@ -287,8 +278,8 @@ function addCurrentAccount(label) {
         return { success: true };
     }
     // 6. New account — back up credentials
-    atomicWriteJson(path.join(getCredentialsDir(), `${active.uuid}.credentials.json`), credBlob);
-    atomicWriteJson(path.join(getConfigsDir(), `${active.uuid}.config.json`), configBlob);
+    (0, atomic_1.atomicWriteJsonSync)(path.join(getCredentialsDir(), `${active.uuid}.credentials.json`), credBlob);
+    (0, atomic_1.atomicWriteJsonSync)(path.join(getConfigsDir(), `${active.uuid}.config.json`), configBlob);
     try {
         writeClaudeProfileMirror(active.uuid, credBlob, configBlob);
     }
@@ -307,7 +298,28 @@ function addCurrentAccount(label) {
     return { success: true };
 }
 // ── Switch to account ────────────────────────────────────────────────────
+/**
+ * Serializes live Claude credential swaps across processes so two concurrent
+ * switchers cannot interleave their backup/write/rollback sequences. It cannot
+ * exclude Claude Code's own writes to the live home — only our switchers. Lock
+ * ordering: this lock first, the registry lock (inside setActiveSavedAccount)
+ * inside it — never the reverse.
+ */
+function withClaudeAuthSwapLock(operation) {
+    const lockDir = path.join((0, accountRegistry_1.getAccountsDir)(), 'claude');
+    fs.mkdirSync(lockDir, { recursive: true, mode: 0o700 });
+    return (0, atomic_1.withFileLockSync)(path.join(lockDir, 'auth-swap.lock'), operation);
+}
 function switchToAccount(uuid) {
+    try {
+        // Keep the non-throwing result contract when the lock cannot be acquired.
+        return withClaudeAuthSwapLock(() => switchToAccountUnlocked(uuid));
+    }
+    catch (err) {
+        return { success: false, error: `Could not acquire the account-switch lock: ${err}` };
+    }
+}
+function switchToAccountUnlocked(uuid) {
     const registry = readAccountRegistry();
     if (!registry) {
         return { success: false, error: 'No account registry found. Save an account first.' };
@@ -338,7 +350,7 @@ function switchToAccount(uuid) {
     catch (err) {
         return { success: false, error: `Failed to update account registry: ${err}` };
     }
-    const applied = applyActiveClaudeToLiveHome();
+    const applied = applyActiveClaudeToLiveHomeUnlocked();
     if (!applied.success) {
         try {
             (0, accountRegistry_1.setActiveSavedAccount)('claude-code', registry.activeAccountUuid);
@@ -373,6 +385,15 @@ function resolveActiveClaudeHome() {
     return (0, claudeProfiles_1.getClaudeProfileHome)(active.providerAccountId ?? active.id);
 }
 function applyActiveClaudeToLiveHome() {
+    try {
+        // Keep the non-throwing result contract when the lock cannot be acquired.
+        return withClaudeAuthSwapLock(applyActiveClaudeToLiveHomeUnlocked);
+    }
+    catch (err) {
+        return { success: false, error: `Could not acquire the account-switch lock: ${err}` };
+    }
+}
+function applyActiveClaudeToLiveHomeUnlocked() {
     const active = (0, accountRegistry_1.getActiveSavedAccount)('claude-code');
     if (!active) {
         return { success: false, error: 'No active Claude account found.' };

package/dist/autoSwitch.d.ts

@@ -36,7 +36,7 @@ export interface AutoSwitchControllerOptions {
     getCodexAccounts?: () => SavedAccountProfile[];
     getActiveCodexAccount?: () => SavedAccountProfile | null;
     readSnapshot?: (providerId: AccountProviderId, accountId: string) => QuotaState | null;
-    switchAccount?: (providerId: AccountProviderId, accountId: string) => AccountManagerResult;
+    switchAccount?: (providerId: AccountProviderId, accountId: string) => AccountManagerResult | Promise<AccountManagerResult>;
     onTransition?: (event: AutoSwitchTransitionEvent) => void;
     log?: (message: string, error?: unknown) => void;
     cooldownMs?: number;
@@ -59,6 +59,7 @@ export declare class AutoSwitchController implements Disposable {
     private subscription;
     private readonly switchedDuringCrossing;
     private readonly lastSwitchAt;
+    private readonly switchInFlight;
     constructor(options: AutoSwitchControllerOptions);
     start(): void;
     stop(): void;