@modelprofile.com/authswitch 6.5.0 → 7.0.0

package/dist_ts/classes.claudenative.js

@@ -0,0 +1,731 @@
+import * as plugins from './plugins.js';
+import { ClaudeCodeLockOutcomeUnknownError, ClaudeCodeLocks } from './classes.claudecodelocks.js';
+import { claudeRequest } from './claudehttp.js';
+import { writeSecretFileAtomically } from './helpers.js';
+import { HarnessProcesses } from './classes.harnessprocesses.js';
+/** The private file and lock contract verified for this Claude Code release. */
+export const CLAUDE_NATIVE_HANDOFF_VERSION = '2.1.273';
+const MAX_NATIVE_FILE_BYTES = 4 * 1024 * 1024;
+const MAX_PROCESS_CONTEXT_BYTES = 1024 * 1024;
+const PROFILE_TIMEOUT_MS = 10_000;
+const ACCOUNT_CACHES = [
+    'additionalModelOptionsCache', 'additionalModelOptionsAnsweredAt', 'additionalModelCostsCache',
+    'modelAccessCache', 'orgModelDefaultCache', 'lastSeenOrgDefaultUpdatedAt', 'clientDataCache',
+    'clientDataCacheSlots', 'autoCompactWindowsCache', 'cachedUsageUtilization',
+];
+const CREDENTIAL_OVERRIDES = [
+    'CLAUDE_CODE_OAUTH_TOKEN', 'CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR', 'ANTHROPIC_API_KEY',
+    'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_PROFILE', 'CLAUDE_CODE_USE_BEDROCK',
+    'CLAUDE_CODE_USE_VERTEX', 'CLAUDE_CODE_USE_FOUNDRY', 'ANTHROPIC_BASE_URL',
+    'ANTHROPIC_FEDERATION_RULE_ID', 'ANTHROPIC_ORGANIZATION_ID',
+    'ANTHROPIC_IDENTITY_TOKEN_FILE', 'ANTHROPIC_IDENTITY_TOKEN', 'ANTHROPIC_WORKSPACE_ID',
+    'ANTHROPIC_UNIX_SOCKET', 'CLAUDE_CODE_REMOTE', 'CLAUDE_CODE_SIMPLE',
+    'CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST', 'CLAUDE_CODE_HOST_AUTH_ENV_VAR',
+    'CLAUDE_CODE_HOST_CREDS_FILE', 'CLAUDE_CODE_SESSION_ACCESS_TOKEN',
+    'CLAUDE_CODE_OAUTH_REFRESH_TOKEN', 'CLAUDE_CODE_API_KEY_FILE_DESCRIPTOR',
+    'CLAUDE_CODE_USE_GATEWAY',
+    'CLAUDE_CODE_GATEWAY_TOKEN_FILE_DESCRIPTOR', 'CLAUDE_CODE_HFI_BEARER_TOKEN',
+    'CLAUDE_BG_AUTH_SNAPSHOT_PATH',
+];
+/** Refusal is distinct from a malformed login: Claude may use a different auth source. */
+export class ClaudeNativeEffectiveAuthUnsupportedError extends Error {
+    reason;
+    code = 'unsupported_effective_auth';
+    constructor(reason) {
+        super(`Cannot prove that Claude Code ${CLAUDE_NATIVE_HANDOFF_VERSION} uses its native claude.ai login (${reason}).`);
+        this.reason = reason;
+    }
+}
+const hash = (value) => plugins.crypto.createHash('sha256').update(value).digest('hex');
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const text = (value) => typeof value === 'string' && value.length > 0;
+const sameDigests = (left, right) => left.credentialDigest === right.credentialDigest && left.configDigest === right.configDigest;
+const onlyDigests = (value) => ({
+    credentialDigest: value.credentialDigest, configDigest: value.configDigest,
+});
+const preparedWrites = new WeakMap();
+const sameIdentity = (left, right) => left.accountUuid === right.accountUuid && left.organizationUuid === right.organizationUuid;
+const pathEnvironment = ['HOME', 'XDG_CONFIG_HOME', 'ANTHROPIC_CONFIG_DIR', 'CLAUDE_CONFIG_DIR'];
+const contextKeys = new Set([...CREDENTIAL_OVERRIDES, ...pathEnvironment]);
+const readProcessContext = (file) => {
+    const descriptor = plugins.fs.openSync(file, plugins.fs.constants.O_RDONLY | plugins.fs.constants.O_NOFOLLOW | plugins.fs.constants.O_NONBLOCK);
+    try {
+        const buffer = Buffer.alloc(MAX_PROCESS_CONTEXT_BYTES + 1);
+        let length = 0;
+        while (length < buffer.length) {
+            const count = plugins.fs.readSync(descriptor, buffer, length, buffer.length - length, null);
+            if (count === 0)
+                break;
+            length += count;
+        }
+        if (length === buffer.length)
+            throw new Error('Claude process context is too large to verify.');
+        return new TextDecoder('utf-8', { fatal: true }).decode(buffer.subarray(0, length));
+    }
+    finally {
+        plugins.fs.closeSync(descriptor);
+    }
+};
+const selectorEnvironment = (raw) => {
+    const selected = {};
+    for (const entry of raw.split('\0')) {
+        const separator = entry.indexOf('=');
+        if (separator < 1)
+            continue;
+        const key = entry.slice(0, separator);
+        if (!contextKeys.has(key))
+            continue;
+        if (Object.hasOwn(selected, key))
+            throw new Error('Claude process environment selector is ambiguous.');
+        // Presence is enough for credential selectors. Never retain their secret value.
+        selected[key] = pathEnvironment.includes(key)
+            ? entry.slice(separator + 1) : entry.length > separator + 1 ? 'present' : '';
+    }
+    return selected;
+};
+const processViewPath = (absolutePath, processRoot) => {
+    if (!plugins.path.isAbsolute(absolutePath)
+        || plugins.path.normalize(absolutePath) !== absolutePath) {
+        throw new ClaudeNativeEffectiveAuthUnsupportedError('running_session');
+    }
+    return processRoot ? plugins.path.join(processRoot, absolutePath.slice(1)) : absolutePath;
+};
+/** 2.1.273's `le` / `dse` / `H` selector in the installed bundle, offset 190076222. */
+const assertNoKnownNativeLoginOverride = (env, processRoot) => {
+    for (const key of CREDENTIAL_OVERRIDES) {
+        if (env[key])
+            throw new ClaudeNativeEffectiveAuthUnsupportedError('override');
+    }
+    const configDir = env.ANTHROPIC_CONFIG_DIR?.trim()
+        || (env.XDG_CONFIG_HOME?.trim()
+            ? plugins.path.join(env.XDG_CONFIG_HOME.trim(), 'anthropic')
+            : env.HOME?.trim() ? plugins.path.join(env.HOME.trim(), '.config', 'anthropic') : null);
+    if (configDir === null)
+        return;
+    if (!plugins.path.isAbsolute(configDir) || plugins.path.normalize(configDir) !== configDir) {
+        throw new ClaudeNativeEffectiveAuthUnsupportedError('profile_unreadable');
+    }
+    let selected = 'default';
+    try {
+        selected = readNativeRaw(processViewPath(plugins.path.join(configDir, 'active_config'), processRoot))?.trim() || 'default';
+        // The vendor's profile resolver otherwise forms `configs/${selected}.json` directly.
+        if (!/^[A-Za-z0-9._-]+$/.test(selected) || selected === '.' || selected === '..') {
+            throw new ClaudeNativeEffectiveAuthUnsupportedError('profile_unreadable');
+        }
+        plugins.fs.lstatSync(processViewPath(plugins.path.join(configDir, 'configs', `${selected}.json`), processRoot));
+    }
+    catch (error) {
+        if (error instanceof ClaudeNativeEffectiveAuthUnsupportedError)
+            throw error;
+        if (error.code === 'ENOENT')
+            return;
+        throw new ClaudeNativeEffectiveAuthUnsupportedError('profile_unreadable');
+    }
+    // Even an implicit user_oauth profile is refused: its credential source is outside this journal.
+    throw new ClaudeNativeEffectiveAuthUnsupportedError('profile');
+};
+const assertNativeHome = (env, configDir) => {
+    const selected = env.CLAUDE_CONFIG_DIR?.trim()
+        || (env.HOME?.trim() ? plugins.path.join(env.HOME.trim(), '.claude') : null);
+    if (!selected || !plugins.path.isAbsolute(selected) || plugins.path.normalize(selected) !== configDir) {
+        throw new ClaudeNativeEffectiveAuthUnsupportedError('override');
+    }
+};
+const selectedNativeConfigParent = (env) => env.CLAUDE_CONFIG_DIR?.trim() || env.HOME?.trim() || null;
+const assertSettingsSelectNative = (file) => {
+    let raw;
+    try {
+        raw = readNativeRaw(file);
+    }
+    catch {
+        throw new ClaudeNativeEffectiveAuthUnsupportedError('settings');
+    }
+    if (raw === null)
+        return;
+    let settings;
+    try {
+        settings = document(raw);
+    }
+    catch {
+        throw new ClaudeNativeEffectiveAuthUnsupportedError('settings');
+    }
+    if (text(settings.apiKeyHelper) || settings.forceLoginMethod || settings.forceLoginGatewayUrl) {
+        throw new ClaudeNativeEffectiveAuthUnsupportedError('settings');
+    }
+    if (settings.env !== undefined) {
+        if (!isRecord(settings.env))
+            throw new ClaudeNativeEffectiveAuthUnsupportedError('settings');
+        for (const key of contextKeys) {
+            if (settings.env[key])
+                throw new ClaudeNativeEffectiveAuthUnsupportedError('settings');
+        }
+    }
+};
+const assertNoManagedAuthSource = (root) => {
+    try {
+        plugins.fs.lstatSync(plugins.path.join(root, 'managed-settings.json'));
+        throw new ClaudeNativeEffectiveAuthUnsupportedError('settings');
+    }
+    catch (error) {
+        if (error instanceof ClaudeNativeEffectiveAuthUnsupportedError)
+            throw error;
+        if (error.code !== 'ENOENT') {
+            throw new ClaudeNativeEffectiveAuthUnsupportedError('settings');
+        }
+    }
+    try {
+        if (plugins.fs.readdirSync(plugins.path.join(root, 'managed-settings.d'))
+            .some(name => !name.startsWith('.') && name.endsWith('.json'))) {
+            throw new ClaudeNativeEffectiveAuthUnsupportedError('settings');
+        }
+    }
+    catch (error) {
+        if (error instanceof ClaudeNativeEffectiveAuthUnsupportedError)
+            throw error;
+        if (error.code !== 'ENOENT') {
+            throw new ClaudeNativeEffectiveAuthUnsupportedError('settings');
+        }
+    }
+};
+const assertProjectSettingsSelectNative = (cwd, processRoot) => {
+    for (let directory = cwd;; directory = plugins.path.dirname(directory)) {
+        for (const name of ['settings.json', 'settings.local.json']) {
+            assertSettingsSelectNative(processViewPath(plugins.path.join(directory, '.claude', name), processRoot));
+        }
+        if (plugins.path.dirname(directory) === directory)
+            break;
+    }
+};
+/** Read native files without following a replacement symlink or accepting an unbounded/partial file. */
+const readNativeBytes = (file) => {
+    let descriptor;
+    try {
+        descriptor = plugins.fs.openSync(file, plugins.fs.constants.O_RDONLY | plugins.fs.constants.O_NONBLOCK | plugins.fs.constants.O_NOFOLLOW);
+        const stat = plugins.fs.fstatSync(descriptor);
+        if (!stat.isFile() || stat.size > MAX_NATIVE_FILE_BYTES || stat.uid !== process.getuid?.()) {
+            throw new Error('Native Claude credential file is not a bounded owner-only regular file.');
+        }
+        const buffer = Buffer.alloc(MAX_NATIVE_FILE_BYTES + 1);
+        let length = 0;
+        while (length < buffer.length) {
+            const count = plugins.fs.readSync(descriptor, buffer, length, buffer.length - length, null);
+            if (count === 0)
+                break;
+            length += count;
+        }
+        if (length === buffer.length)
+            throw new Error('Native Claude credential file exceeds the supported size.');
+        // Keep the original bytes: TextDecoder accepts a BOM but strips it from text.
+        const bytes = buffer.subarray(0, length);
+        new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        return bytes;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw new Error('Native Claude credential file is unreadable or changed; no new credential was written.');
+    }
+    finally {
+        if (descriptor !== undefined)
+            plugins.fs.closeSync(descriptor);
+    }
+};
+const decodeNativeRaw = (bytes) => bytes === null ? null
+    : new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+const readNativeRaw = (file) => decodeNativeRaw(readNativeBytes(file));
+const document = (raw) => {
+    if (raw === null)
+        return {};
+    try {
+        const value = JSON.parse(typeof raw === 'string' ? raw : decodeNativeRaw(raw));
+        if (isRecord(value))
+            return value;
+    }
+    catch { /* Report one fixed, secret-free error. */ }
+    throw new Error('Native Claude credential file is incomplete or malformed.');
+};
+const validatedLogin = (credential, config) => {
+    if (text(config.primaryApiKey)) {
+        // 2.1.273 `qh` / `lge` reads this /login-managed API key before subscriber OAuth.
+        throw new ClaudeNativeEffectiveAuthUnsupportedError('override');
+    }
+    const oauthValue = credential.claudeAiOauth;
+    const accountValue = config.oauthAccount;
+    if (oauthValue === undefined && accountValue === undefined)
+        return { login: null, identity: null };
+    if (!isRecord(oauthValue) || !isRecord(accountValue)
+        || !text(oauthValue.accessToken) || !text(oauthValue.refreshToken)
+        || typeof oauthValue.expiresAt !== 'number' || !Number.isFinite(oauthValue.expiresAt)
+        || !Array.isArray(oauthValue.scopes) || !oauthValue.scopes.every(scope => typeof scope === 'string')
+        || !text(accountValue.accountUuid) || !text(accountValue.organizationUuid)) {
+        throw new Error('Native Claude login or account metadata is incomplete.');
+    }
+    // `Sc` / `CO` and the full native subscription gate in 2.1.273 require these fields.
+    if (!oauthValue.scopes.includes('user:inference')
+        || (oauthValue.subscriptionType !== 'pro' && oauthValue.subscriptionType !== 'max')) {
+        throw new ClaudeNativeEffectiveAuthUnsupportedError('subscription');
+    }
+    return {
+        login: { claudeAiOauth: structuredClone(oauthValue), oauthAccount: structuredClone(accountValue) },
+        identity: { accountUuid: accountValue.accountUuid, organizationUuid: accountValue.organizationUuid },
+    };
+};
+const readPair = (credentialFile, configFile) => ({ credentialRaw: readNativeBytes(credentialFile), configRaw: readNativeBytes(configFile) });
+const sameRaw = (left, right) => left === null ? right === null : right !== null && left.equals(right);
+const samePair = (left, right) => sameRaw(left.credentialRaw, right.credentialRaw) && sameRaw(left.configRaw, right.configRaw);
+const digests = (pair) => ({
+    credentialDigest: pair.credentialRaw === null ? null : hash(pair.credentialRaw),
+    configDigest: pair.configRaw === null ? null : hash(pair.configRaw),
+});
+const directoryIdentity = (directory) => {
+    const stat = plugins.fs.statSync(directory, { bigint: true });
+    if (!stat.isDirectory())
+        throw new Error('Claude native home is not a directory.');
+    return { device: stat.dev, inode: stat.ino };
+};
+const sameDirectory = (left, right) => left.device === right.device && left.inode === right.inode;
+const processHasExited = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return false;
+    }
+    catch (error) {
+        return error.code === 'ESRCH';
+    }
+};
+/** Default probe is conservative: every same-user Claude executable must prove the pinned release. */
+class ClaudeNativeVersionProbe {
+    executable;
+    constructor(executable) {
+        this.executable = executable;
+    }
+    installedVersion() {
+        try {
+            const output = plugins.childProcess.execFileSync(this.executable, ['--version'], {
+                encoding: 'utf8', timeout: 5_000, maxBuffer: 1024, windowsHide: true,
+            }).trim();
+            const matched = /^(\d+\.\d+\.\d+) \(Claude Code\)$/.exec(output);
+            return matched?.[1] ?? 'unknown';
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    runningContexts() {
+        const contexts = [];
+        // Keep candidates from every mount namespace: a bind mount can expose the same inode.
+        const candidates = new HarnessProcesses('claude').list();
+        for (const running of candidates) {
+            let version = null;
+            let env = null;
+            let cwd = null;
+            let hasSettingsOverride = null;
+            let nativeHomeIdentity = null;
+            let configParentIdentity = null;
+            let mountNamespace = null;
+            let processRoot = null;
+            try {
+                const executable = plugins.fs.readlinkSync(`/proc/${running.pid}/exe`);
+                version = /(?:\/claude\/versions\/|\/remote\/ccd-cli\/)(\d+\.\d+\.\d+)$/.exec(executable)?.[1] ?? null;
+                mountNamespace = plugins.fs.readlinkSync(`/proc/${running.pid}/ns/mnt`);
+                env = selectorEnvironment(readProcessContext(`/proc/${running.pid}/environ`));
+                cwd = plugins.fs.readlinkSync(`/proc/${running.pid}/cwd`);
+                processRoot = `/proc/${running.pid}/root`;
+                if (!plugins.path.isAbsolute(cwd) || !sameDirectory(directoryIdentity(`/proc/${running.pid}/cwd`), directoryIdentity(processViewPath(cwd, processRoot)))) {
+                    throw new Error('Claude process working directory cannot be resolved in its mount namespace.');
+                }
+                const selectedHome = env.CLAUDE_CONFIG_DIR?.trim()
+                    || (env.HOME?.trim() ? plugins.path.join(env.HOME.trim(), '.claude') : null);
+                if (!selectedHome)
+                    throw new Error('Claude process native home is unknown.');
+                if (plugins.path.isAbsolute(selectedHome)
+                    && plugins.path.normalize(selectedHome) !== selectedHome) {
+                    throw new Error('Claude process native home path is ambiguous.');
+                }
+                const processHome = plugins.path.isAbsolute(selectedHome)
+                    ? processViewPath(selectedHome, processRoot)
+                    // Preserve the proc magic symlink before `..` is resolved by the target's VFS.
+                    : `/proc/${running.pid}/cwd/${selectedHome}`;
+                nativeHomeIdentity = directoryIdentity(processHome);
+                const selectedConfigParent = selectedNativeConfigParent(env);
+                if (!selectedConfigParent)
+                    throw new Error('Claude process config parent is unknown.');
+                const processConfigParent = plugins.path.isAbsolute(selectedConfigParent)
+                    ? processViewPath(selectedConfigParent, processRoot)
+                    : `/proc/${running.pid}/cwd/${selectedConfigParent}`;
+                configParentIdentity = directoryIdentity(processConfigParent);
+                const argv = readProcessContext(`/proc/${running.pid}/cmdline`).split('\0').filter(Boolean);
+                hasSettingsOverride = argv.some(arg => ['--settings', '--managed-settings', '--setting-sources', '--bare'].some(flag => arg === flag || arg.startsWith(`${flag}=`)));
+            }
+            catch {
+                // A vanished process no longer owns a grant; an unreadable live candidate is ambiguous.
+                if (processHasExited(running.pid))
+                    continue;
+            }
+            contexts.push({ version, env, cwd, hasSettingsOverride, nativeHomeIdentity,
+                configParentIdentity, mountNamespace, processRoot });
+        }
+        return contexts;
+    }
+}
+/** Explicitly limited to Claude Code's installed 2.1.273 Linux native-file contract. */
+export class ClaudeNativeAdapter {
+    options;
+    credentialFile;
+    locks;
+    versionProbe;
+    fetcher;
+    env;
+    settingsFiles;
+    platform;
+    constructor(options) {
+        this.options = options;
+        if (!plugins.path.isAbsolute(options.configDir) || !plugins.path.isAbsolute(options.configFile)
+            || plugins.path.normalize(options.configDir) !== options.configDir
+            || plugins.path.normalize(options.configFile) !== options.configFile) {
+            throw new Error('Native Claude paths must be normalized absolute paths.');
+        }
+        if (![plugins.path.join(options.configDir, '.claude.json'),
+            plugins.path.join(plugins.os.homedir(), '.claude.json')].includes(options.configFile)) {
+            throw new Error('Native Claude account metadata must use its vendor config file.');
+        }
+        this.credentialFile = plugins.path.join(options.configDir, '.credentials.json');
+        this.locks = new ClaudeCodeLocks(options.configDir, options.configFile, { timeoutMs: options.lockTimeoutMs });
+        this.versionProbe = options.versionProbe ?? new ClaudeNativeVersionProbe(options.executable ?? 'claude');
+        this.fetcher = options.fetch ?? globalThis.fetch;
+        this.env = options.env ?? process.env;
+        this.settingsFiles = options.settingsFiles ?? [plugins.path.join(options.configDir, 'settings.json'),
+            plugins.path.join(process.cwd(), '.claude/settings.json'),
+            plugins.path.join(process.cwd(), '.claude/settings.local.json')];
+        this.platform = options.platform ?? process.platform;
+    }
+    assertSupported() {
+        if (this.platform !== 'linux')
+            throw new Error('Native Claude handoff requires the verified Linux file backend.');
+        const home = plugins.fs.lstatSync(this.options.configDir);
+        if (!home.isDirectory() || home.isSymbolicLink() || home.uid !== process.getuid?.()
+            || plugins.fs.realpathSync(this.options.configDir) !== this.options.configDir) {
+            throw new Error('Native Claude home must be a real directory owned by this user.');
+        }
+        const configParent = plugins.path.dirname(this.options.configFile);
+        const parent = plugins.fs.lstatSync(configParent);
+        if (!parent.isDirectory() || parent.isSymbolicLink() || parent.uid !== process.getuid?.()
+            || plugins.fs.realpathSync(configParent) !== configParent) {
+            throw new Error('Native Claude account metadata parent must be a real directory owned by this user.');
+        }
+        assertNoKnownNativeLoginOverride(this.env);
+        assertNativeHome(this.env, this.options.configDir);
+        const daemonConfigParent = selectedNativeConfigParent(this.env);
+        if (!daemonConfigParent || !plugins.path.isAbsolute(daemonConfigParent)
+            || plugins.path.join(daemonConfigParent, '.claude.json') !== this.options.configFile) {
+            throw new ClaudeNativeEffectiveAuthUnsupportedError('override');
+        }
+        assertNoManagedAuthSource(this.options.managedSettingsDirectory ?? '/etc/claude-code');
+        for (const file of this.settingsFiles) {
+            assertSettingsSelectNative(file);
+        }
+        if (this.versionProbe.installedVersion() !== CLAUDE_NATIVE_HANDOFF_VERSION) {
+            throw new Error(`Native Claude handoff requires Claude Code ${CLAUDE_NATIVE_HANDOFF_VERSION} for every active session.`);
+        }
+        let runningSessions = 0;
+        const nativeHomeIdentity = directoryIdentity(this.options.configDir);
+        const configParentIdentity = directoryIdentity(configParent);
+        for (const running of this.versionProbe.runningContexts()) {
+            if (!running.nativeHomeIdentity) {
+                throw new ClaudeNativeEffectiveAuthUnsupportedError('running_session');
+            }
+            if (!sameDirectory(running.nativeHomeIdentity, nativeHomeIdentity))
+                continue;
+            if (!running.configParentIdentity
+                || !sameDirectory(running.configParentIdentity, configParentIdentity)) {
+                throw new ClaudeNativeEffectiveAuthUnsupportedError('running_session');
+            }
+            if (running.version !== CLAUDE_NATIVE_HANDOFF_VERSION) {
+                throw new Error(`Native Claude handoff requires Claude Code ${CLAUDE_NATIVE_HANDOFF_VERSION} for every active session.`);
+            }
+            if (!running.env || !running.cwd || running.hasSettingsOverride === null
+                || !running.mountNamespace || !running.processRoot) {
+                throw new ClaudeNativeEffectiveAuthUnsupportedError('running_session');
+            }
+            if (running.hasSettingsOverride)
+                throw new ClaudeNativeEffectiveAuthUnsupportedError('override');
+            assertNoKnownNativeLoginOverride(running.env, running.processRoot);
+            assertNoManagedAuthSource(processViewPath(this.options.managedSettingsDirectory ?? '/etc/claude-code', running.processRoot));
+            assertProjectSettingsSelectNative(running.cwd, running.processRoot);
+            runningSessions++;
+        }
+        return runningSessions;
+    }
+    /** The caller keeps its SmartData journal and both ownership transactions inside this callback. */
+    async withExclusiveHome(action) {
+        this.assertSupported();
+        return this.locks.holdAsync(async (lease) => {
+            this.assertSupported();
+            const session = new ClaudeNativeLockedSession(this.credentialFile, this.options.configFile, this.fetcher, lease, () => this.assertSupported());
+            const firstSnapshot = session.readStable();
+            const result = await action(session);
+            try {
+                lease.assertHeld();
+                const afterRunningSessions = this.assertSupported();
+                if (firstSnapshot.runningEffectiveAuth === 'no_scoped_sessions' && afterRunningSessions > 0) {
+                    throw new ClaudeNativeEffectiveAuthUnsupportedError('running_session');
+                }
+            }
+            catch {
+                // The caller may already have committed a journal or changed one native file.
+                throw new ClaudeCodeLockOutcomeUnknownError(true);
+            }
+            return result;
+        });
+    }
+}
+class ClaudeNativeLockedSession {
+    credentialFile;
+    configFile;
+    fetcher;
+    lease;
+    assertSupported;
+    constructor(credentialFile, configFile, fetcher, lease, assertSupported) {
+        this.credentialFile = credentialFile;
+        this.configFile = configFile;
+        this.fetcher = fetcher;
+        this.lease = lease;
+        this.assertSupported = assertSupported;
+    }
+    observation() {
+        try {
+            return digests(readPair(this.credentialFile, this.configFile));
+        }
+        catch {
+            return null;
+        }
+    }
+    readStable() {
+        this.lease.assertHeld();
+        const runningSessions = this.assertSupported();
+        let lastError;
+        for (let attempt = 0; attempt < 5; attempt++) {
+            try {
+                const before = readPair(this.credentialFile, this.configFile);
+                const credential = document(before.credentialRaw);
+                const config = document(before.configRaw);
+                const observed = validatedLogin(credential, config);
+                const after = readPair(this.credentialFile, this.configFile);
+                if (samePair(before, after)) {
+                    this.lease.assertHeld();
+                    return { ...digests(after), ...observed,
+                        runningEffectiveAuth: runningSessions === 0 ? 'no_scoped_sessions' : 'unsupported_effective_auth' };
+                }
+            }
+            catch (error) {
+                if (error instanceof ClaudeCodeLockOutcomeUnknownError)
+                    throw error;
+                lastError = error;
+            }
+            if (attempt < 4) {
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+            }
+        }
+        if (lastError instanceof ClaudeNativeEffectiveAuthUnsupportedError)
+            throw lastError;
+        throw new Error(lastError instanceof Error ? lastError.message
+            : 'Native Claude files changed while being read; no credential was written.');
+    }
+    async verifyProfileIdentity(snapshot, expected) {
+        this.lease.assertHeld();
+        this.assertSupported();
+        const token = snapshot.login?.claudeAiOauth.accessToken;
+        if (!text(token) || !snapshot.identity || !sameIdentity(snapshot.identity, expected)) {
+            throw new Error('Native Claude login identity differs from the selected account.');
+        }
+        const response = await claudeRequest(this.fetcher, {
+            url: 'https://api.anthropic.com/api/oauth/profile', method: 'GET',
+            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json', 'Cache-Control': 'no-cache' },
+            subject: 'Claude account', timeoutMs: PROFILE_TIMEOUT_MS, now: Date.now,
+        });
+        this.lease.assertHeld();
+        const current = this.observation();
+        if (!current || !sameDigests(current, snapshot)) {
+            throw new Error('Native Claude login changed during provider identity verification.');
+        }
+        if (response.status !== 200 || !isRecord(response.body)
+            || !isRecord(response.body.account) || !isRecord(response.body.organization)
+            || response.body.account.uuid !== expected.accountUuid
+            || response.body.organization.uuid !== expected.organizationUuid) {
+            throw new Error('Claude account profile did not verify the selected immutable identity.');
+        }
+        return { ...expected, accessTokenDigest: hash(token) };
+    }
+    async prepareWrite(input) {
+        this.lease.assertHeld();
+        this.assertSupported();
+        let before;
+        try {
+            before = this.readStable();
+        }
+        catch {
+            return { kind: 'not_written', reason: 'source_unreadable', observed: this.observation() };
+        }
+        if (!sameDigests(before, input.expected)) {
+            return { kind: 'not_written', reason: 'source_changed', observed: onlyDigests(before) };
+        }
+        if (input.expectedSourceIdentity === null ? before.identity !== null
+            : before.identity === null || !sameIdentity(before.identity, input.expectedSourceIdentity)) {
+            return { kind: 'not_written', reason: 'source_identity_mismatch', observed: onlyDigests(before) };
+        }
+        let target;
+        try {
+            target = validatedLogin({ claudeAiOauth: input.targetLogin.claudeAiOauth }, { oauthAccount: input.targetLogin.oauthAccount });
+        }
+        catch {
+            return { kind: 'not_written', reason: 'target_unverified', observed: onlyDigests(before) };
+        }
+        if (!target.login || !target.identity || !sameIdentity(target.identity, input.expectedIdentity)) {
+            return { kind: 'not_written', reason: 'target_unverified', observed: onlyDigests(before) };
+        }
+        let profile;
+        try {
+            profile = await this.verifyProfileIdentity({ ...before, ...target }, input.expectedIdentity);
+        }
+        catch {
+            this.lease.assertHeld();
+            this.assertSupported();
+            const observed = this.observation();
+            if (!observed)
+                return { kind: 'not_written', reason: 'source_unreadable', observed: null };
+            if (!sameDigests(observed, input.expected)) {
+                return { kind: 'not_written', reason: 'source_changed', observed };
+            }
+            return { kind: 'not_written', reason: 'target_unverified', observed: onlyDigests(before) };
+        }
+        const current = this.observation();
+        if (!current || !sameDigests(current, input.expected)) {
+            return { kind: 'not_written', reason: 'source_changed', observed: current };
+        }
+        this.lease.assertHeld();
+        this.assertSupported();
+        let original;
+        try {
+            original = readPair(this.credentialFile, this.configFile);
+        }
+        catch {
+            return { kind: 'not_written', reason: 'source_unreadable', observed: this.observation() };
+        }
+        if (!sameDigests(digests(original), input.expected)) {
+            return { kind: 'not_written', reason: 'source_changed', observed: digests(original) };
+        }
+        const credential = document(original.credentialRaw);
+        const config = document(original.configRaw);
+        const nextCredential = { ...credential, claudeAiOauth: target.login.claudeAiOauth };
+        const nextConfig = { ...config, oauthAccount: target.login.oauthAccount };
+        for (const key of ACCOUNT_CACHES)
+            delete nextConfig[key];
+        const credentialRaw = JSON.stringify(nextCredential, null, 2) + '\n';
+        const configRaw = JSON.stringify(nextConfig, null, 2) + '\n';
+        if (Buffer.byteLength(credentialRaw) > MAX_NATIVE_FILE_BYTES
+            || Buffer.byteLength(configRaw) > MAX_NATIVE_FILE_BYTES) {
+            return { kind: 'not_written', reason: 'target_oversized', observed: onlyDigests(before) };
+        }
+        const plan = Object.freeze({
+            before: Object.freeze(onlyDigests(input.expected)),
+            after: Object.freeze(digests({ credentialRaw: Buffer.from(credentialRaw), configRaw: Buffer.from(configRaw) })),
+            sourceIdentity: input.expectedSourceIdentity === null ? null : Object.freeze({ ...input.expectedSourceIdentity }),
+            targetIdentity: Object.freeze({ ...input.expectedIdentity }),
+            profile: Object.freeze({ ...profile }),
+        });
+        preparedWrites.set(plan, { session: this, credentialRaw, configRaw,
+            originalConfigRaw: original.configRaw, targetAccessToken: String(target.login.claudeAiOauth.accessToken) });
+        return { kind: 'prepared', plan };
+    }
+    exportPreparedSource(plan) {
+        this.lease.assertHeld();
+        this.assertSupported();
+        const prepared = preparedWrites.get(plan);
+        if (!prepared || prepared.session !== this)
+            throw new Error('Claude native write plan is not held by this lease.');
+        const stable = this.readStable();
+        if (!sameDigests(stable, plan.before)
+            || (plan.sourceIdentity === null ? stable.identity !== null
+                : stable.identity === null || !sameIdentity(stable.identity, plan.sourceIdentity))) {
+            throw new Error('Claude native source changed before backup export.');
+        }
+        const original = readPair(this.credentialFile, this.configFile);
+        if (!sameDigests(digests(original), plan.before)
+            || !sameRaw(original.configRaw, prepared.originalConfigRaw)) {
+            throw new Error('Claude native source changed before backup export.');
+        }
+        this.lease.assertHeld();
+        this.assertSupported();
+        return { before: Object.freeze({ ...plan.before }),
+            credentialBytes: original.credentialRaw === null ? null : Buffer.from(original.credentialRaw),
+            configBytes: original.configRaw === null ? null : Buffer.from(original.configRaw) };
+    }
+    writePreparedIfCurrent(plan) {
+        this.lease.assertHeld();
+        this.assertSupported();
+        const prepared = preparedWrites.get(plan);
+        if (!prepared || prepared.session !== this)
+            throw new Error('Claude native write plan is not held by this lease.');
+        preparedWrites.delete(plan);
+        let before;
+        try {
+            before = this.readStable();
+        }
+        catch {
+            return { kind: 'not_written', reason: 'source_unreadable', observed: this.observation() };
+        }
+        if (!sameDigests(before, plan.before)) {
+            return { kind: 'not_written', reason: 'source_changed', observed: onlyDigests(before) };
+        }
+        if (plan.sourceIdentity === null ? before.identity !== null
+            : before.identity === null || !sameIdentity(before.identity, plan.sourceIdentity)) {
+            return { kind: 'not_written', reason: 'source_identity_mismatch', observed: onlyDigests(before) };
+        }
+        let original;
+        try {
+            original = readPair(this.credentialFile, this.configFile);
+        }
+        catch {
+            return { kind: 'not_written', reason: 'source_unreadable', observed: this.observation() };
+        }
+        if (!sameDigests(digests(original), plan.before)
+            || !sameRaw(original.configRaw, prepared.originalConfigRaw)) {
+            return { kind: 'not_written', reason: 'source_changed', observed: digests(original) };
+        }
+        // The first write is the uncertainty boundary; no automatic rollback can prove ownership after it.
+        try {
+            this.lease.assertHeld();
+            writeSecretFileAtomically(this.credentialFile, prepared.credentialRaw);
+            this.lease.assertHeld();
+            const middle = readPair(this.credentialFile, this.configFile);
+            if (!sameRaw(middle.credentialRaw, Buffer.from(prepared.credentialRaw))
+                || !sameRaw(middle.configRaw, original.configRaw)) {
+                return { kind: 'uncertain', reason: 'native_write_or_readback_failed', observed: digests(middle) };
+            }
+            writeSecretFileAtomically(this.configFile, prepared.configRaw);
+            this.lease.assertHeld();
+            const after = readPair(this.credentialFile, this.configFile);
+            if (!sameRaw(after.credentialRaw, Buffer.from(prepared.credentialRaw))
+                || !sameRaw(after.configRaw, Buffer.from(prepared.configRaw))
+                || !sameDigests(digests(after), plan.after)) {
+                return { kind: 'uncertain', reason: 'native_write_or_readback_failed', observed: digests(after) };
+            }
+            const snapshot = this.readStable();
+            if (!snapshot.login || !snapshot.identity || !sameIdentity(snapshot.identity, plan.targetIdentity)
+                || !sameDigests(snapshot, plan.after)
+                || snapshot.login.claudeAiOauth.accessToken !== prepared.targetAccessToken
+                || plan.profile.accessTokenDigest !== hash(String(snapshot.login.claudeAiOauth.accessToken))) {
+                return { kind: 'uncertain', reason: 'native_write_or_readback_failed', observed: onlyDigests(snapshot) };
+            }
+            return { kind: 'written', snapshot, profile: plan.profile };
+        }
+        catch {
+            return { kind: 'uncertain', reason: 'native_write_or_readback_failed', observed: this.observation() };
+        }
+    }
+    async writeIfCurrent(input) {
+        const prepared = await this.prepareWrite(input);
+        return prepared.kind === 'prepared' ? this.writePreparedIfCurrent(prepared.plan) : prepared;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.claudenative.js","sourceRoot":"","sources":["../ts/classes.claudenative.ts"],"names":[],"mappings":"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"}