@cortexkit/anthropic-auth-core 1.23.0 → 2.0.0

package/dist/cch.js

@@ -1,172 +0,0 @@
-import { createHash } from 'node:crypto';
-import xxhashInit from 'xxhash-wasm';
-import { CCH_POSITIONS, CCH_SALT, CLAUDE_CODE_VERSION } from './constants.js';
-const ANTHROPIC_REQUEST_ID_PATTERN = /^req_[A-Za-z0-9_-]{8,128}$/;
-const PROMPT_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const BILLING_LINEAGE_FIELD_PATTERN = / cc_(?:prev_req|prompt_id)=[^;\r\n]*;/g;
-export function isValidAnthropicRequestId(value) {
-    return ANTHROPIC_REQUEST_ID_PATTERN.test(value);
-}
-export function isValidBillingPromptId(value) {
-    return PROMPT_ID_PATTERN.test(value);
-}
-const CCH_SEED = 0x4d659218e32a3268n;
-const CCH_PLACEHOLDER = 'cch=00000;';
-export const CCH_PATTERN = /\bcch=([0-9a-f]{5});/;
-const BILLING_HEADER_CCH_PATTERN = /("system":\[\{"type":"text","text":"x-anthropic-billing-header: cc_version=[^;"]+; cc_entrypoint=[^;"]+; )cch=([0-9a-f]{5});/;
-const BILLING_HEADER_CCH_PLACEHOLDER_PATTERN = /("system":\[\{"type":"text","text":"x-anthropic-billing-header: cc_version=[^;"]+; cc_entrypoint=[^;"]+; )cch=00000;/;
-let xxhashPromise = null;
-let xxhash64Raw = null;
-async function ensureXxhash() {
-    if (xxhash64Raw)
-        return;
-    xxhashPromise ??= (async () => {
-        const hasher = await xxhashInit();
-        xxhash64Raw = hasher.h64Raw;
-    })();
-    await xxhashPromise;
-}
-/**
- * Extract the visible prompt from the first user message. Claude Code prepends
- * reminder blocks and derives its version suffix from the final text block.
- */
-export function extractFirstUserMessageText(messages) {
-    const userMsg = messages.find((message) => message.role === 'user');
-    if (!userMsg)
-        return '';
-    const { content } = userMsg;
-    if (typeof content === 'string')
-        return content;
-    if (Array.isArray(content)) {
-        const textBlocks = content.filter((block) => block.type === 'text');
-        const commandBlock = textBlocks.find((block) => block.text?.includes('<command-name>'));
-        if (commandBlock?.text) {
-            return commandBlock.text.slice(commandBlock.text.indexOf('<command-name>'));
-        }
-        const visibleBlock = textBlocks.findLast((block) => typeof block.text === 'string' && block.text.length > 0);
-        if (visibleBlock?.text)
-            return visibleBlock.text;
-    }
-    return '';
-}
-export class ClaudeCodeFirstUserTextTracker {
-    limit;
-    #values = new Map();
-    constructor(limit = 1_000) {
-        this.limit = limit;
-    }
-    resolve(sessionId, messages, pin = true) {
-        const existing = this.#values.get(sessionId);
-        if (existing !== undefined) {
-            this.#values.delete(sessionId);
-            this.#values.set(sessionId, existing);
-            return existing;
-        }
-        const value = extractFirstUserMessageText(messages);
-        if (pin) {
-            if (!this.#values.has(sessionId) && this.#values.size >= this.limit) {
-                const oldest = this.#values.keys().next().value;
-                if (oldest !== undefined)
-                    this.#values.delete(oldest);
-            }
-            this.#values.set(sessionId, value);
-        }
-        return value;
-    }
-    has(sessionId) {
-        return this.#values.has(sessionId);
-    }
-    clear() {
-        this.#values.clear();
-    }
-}
-/**
- * Compute Claude Code's cch token over the final serialized request body.
- *
- * Real Claude Code signs the full body bytes with xxHash64 using a fixed seed,
- * masks to 20 bits, and writes that value into the billing-header placeholder.
- */
-export async function computeCCH(bodyBytes) {
-    await ensureXxhash();
-    const hash = xxhash64Raw?.(bodyBytes, CCH_SEED) ?? 0n;
-    return (hash & 0xfffffn).toString(16).padStart(5, '0');
-}
-export async function computeXxhash64Hex(value) {
-    await ensureXxhash();
-    const hash = xxhash64Raw?.(new TextEncoder().encode(value), 0n) ?? 0n;
-    return hash.toString(16).padStart(16, '0').slice(0, 16);
-}
-export function resetBillingHeaderCCH(bodyString) {
-    return bodyString.replace(BILLING_HEADER_CCH_PATTERN, `$1${CCH_PLACEHOLDER}`);
-}
-export function extractBillingHeaderCCH(bodyString) {
-    return BILLING_HEADER_CCH_PATTERN.exec(bodyString)?.[2] ?? null;
-}
-export async function signRequestBody(bodyString) {
-    if (!BILLING_HEADER_CCH_PATTERN.test(bodyString))
-        return bodyString;
-    const unsignedBodyString = resetBillingHeaderCCH(bodyString);
-    const canonicalBody = JSON.parse(unsignedBodyString);
-    if ('model' in canonicalBody)
-        canonicalBody.model = '';
-    delete canonicalBody.max_tokens;
-    const token = await computeCCH(new TextEncoder().encode(JSON.stringify(canonicalBody)));
-    return unsignedBodyString.replace(BILLING_HEADER_CCH_PLACEHOLDER_PATTERN, `$1cch=${token};`);
-}
-/**
- * Compute Claude Code's 3-character suffix for cc_version.
- */
-export function computeCcVersionSuffix(firstUserText, version = CLAUDE_CODE_VERSION) {
-    const sampledText = CCH_POSITIONS.map((position) => firstUserText[position] ?? '0').join('');
-    return createHash('sha256')
-        .update(`${CCH_SALT}${sampledText}${version}`)
-        .digest('hex')
-        .slice(0, 3);
-}
-/**
- * Build the billing header with a cch placeholder.
- * signRequestBody() must run after final request serialization to replace it.
- */
-export function buildBillingHeaderValue(messages, version = CLAUDE_CODE_VERSION, entrypoint, pinnedFirstUserText, lineage) {
-    const suffix = computeCcVersionSuffix(pinnedFirstUserText ?? extractFirstUserMessageText(messages), version);
-    let value = 'x-anthropic-billing-header: ' +
-        `cc_version=${version}.${suffix}; ` +
-        `cc_entrypoint=${entrypoint}; ` +
-        'cch=00000;';
-    if (lineage?.previousRequestId &&
-        isValidAnthropicRequestId(lineage.previousRequestId)) {
-        value += ` cc_prev_req=${lineage.previousRequestId};`;
-    }
-    if (lineage?.promptId && isValidBillingPromptId(lineage.promptId)) {
-        value += ` cc_prompt_id=${lineage.promptId};`;
-    }
-    return value;
-}
-/** Remove request-scoped Claude Code lineage from a billing header string. */
-export function stripBillingLineageFields(value) {
-    return value.replace(BILLING_LINEAGE_FIELD_PATTERN, '');
-}
-/** Remove request-scoped Claude Code lineage before reusing a request body. */
-export function stripBillingLineageFromBody(body) {
-    if (!body || typeof body !== 'object')
-        return 0;
-    const system = body.system;
-    if (!Array.isArray(system))
-        return 0;
-    let stripped = 0;
-    for (const block of system) {
-        if (!block || typeof block !== 'object')
-            continue;
-        const text = block.text;
-        if (typeof text !== 'string' ||
-            !text.startsWith('x-anthropic-billing-header:')) {
-            continue;
-        }
-        const clean = stripBillingLineageFields(text);
-        if (clean === text)
-            continue;
-        block.text = clean;
-        stripped += 1;
-    }
-    return stripped;
-}

package/dist/claude-code.js

@@ -1,403 +0,0 @@
-import { randomBytes, randomUUID } from 'node:crypto';
-import { CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_STAINLESS_PACKAGE_VERSION, CLAUDE_CODE_STAINLESS_RUNTIME_VERSION, CLAUDE_CODE_VERSION, FAST_MODE_BETA, USER_AGENT, } from './constants.js';
-const IDENTITY_CACHE_LIMIT = 1_000;
-const identityCache = new Map();
-export function setBounded(map, key, value, limit = IDENTITY_CACHE_LIMIT) {
-    if (!map.has(key) && map.size >= limit) {
-        const oldest = map.keys().next().value;
-        if (oldest !== undefined)
-            map.delete(oldest);
-    }
-    map.set(key, value);
-}
-function clearCachedAccountUuid(key, identity) {
-    if (!identity.accountUuid)
-        return identity;
-    if (identityCache.get(key) !== identity) {
-        return { ...identity, accountUuid: undefined };
-    }
-    const cleared = { ...identity, accountUuid: undefined };
-    setBounded(identityCache, key, cleared);
-    return cleared;
-}
-export function getClaudeCodeIdentity(seed) {
-    const cacheKey = seed || 'anonymous';
-    const cached = identityCache.get(cacheKey);
-    if (cached)
-        return cached;
-    const identity = {
-        deviceId: randomBytes(32).toString('hex'),
-        sessionId: randomUUID(),
-    };
-    setBounded(identityCache, cacheKey, identity);
-    return identity;
-}
-const BOOTSTRAP_IDENTITY_CACHE_TTL_MS = 24 * 60 * 60_000;
-const BOOTSTRAP_IDENTITY_NEGATIVE_TTL_MS = 5 * 60_000;
-const bootstrapFetches = new Map();
-const bootstrapResults = new Map();
-export function resetClaudeCodeIdentityCachesForTest() {
-    identityCache.clear();
-    bootstrapFetches.clear();
-    bootstrapResults.clear();
-}
-function compatibilityCacheKey(accessToken) {
-    return `compat:${accessToken || 'anonymous'}`;
-}
-function explicitCacheKey(accountIdentity) {
-    return `identity:${accountIdentity}`;
-}
-function accountCacheKey(accountUuid, accountIdentity) {
-    return `account:${accountUuid}:${accountIdentity}`;
-}
-function adoptCachedIdentity(cached, accountIdentity, accountUuid) {
-    if (!cached)
-        return undefined;
-    if (cached.accountIdentity !== undefined &&
-        cached.accountIdentity !== accountIdentity) {
-        return undefined;
-    }
-    if (accountUuid !== undefined &&
-        cached.accountUuid !== undefined &&
-        cached.accountUuid !== accountUuid) {
-        return undefined;
-    }
-    if (cached.accountIdentity === accountIdentity &&
-        (accountUuid === undefined || cached.accountUuid === accountUuid)) {
-        return cached;
-    }
-    return {
-        ...cached,
-        accountIdentity,
-        ...(accountUuid !== undefined && { accountUuid }),
-    };
-}
-function cacheAccountIdentity(identity, accountIdentity, accountUuid) {
-    setBounded(identityCache, explicitCacheKey(accountIdentity), identity);
-    setBounded(identityCache, accountCacheKey(accountUuid, accountIdentity), identity);
-}
-async function fetchClaudeCodeAccountUuid(accessToken, model) {
-    if (!accessToken.startsWith('sk-ant-oat'))
-        return null;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 5_000);
-    try {
-        const url = new URL('https://api.anthropic.com/api/claude_cli/bootstrap');
-        url.searchParams.set('entrypoint', CLAUDE_CODE_ENTRYPOINT);
-        if (model)
-            url.searchParams.set('model', model);
-        const response = await fetch(url, {
-            method: 'GET',
-            headers: {
-                accept: 'application/json, text/plain, */*',
-                authorization: `Bearer ${accessToken}`,
-                'content-type': 'application/json',
-                'anthropic-beta': 'oauth-2025-04-20',
-                'user-agent': `claude-code/${CLAUDE_CODE_VERSION}`,
-            },
-            signal: controller.signal,
-        });
-        if (!response.ok)
-            return null;
-        const data = (await response.json().catch(() => null));
-        const accountUuid = data?.oauth_account?.account_uuid;
-        return typeof accountUuid === 'string' && accountUuid
-            ? accountUuid
-            : null;
-    }
-    catch {
-        return null;
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-/** Use the identity already verified by the credential custodian, without an
- * additional bootstrap request carrying a previously authorized token. */
-export function getClaudeCodeIdentityForVerifiedAccount(accountIdentity, accountUuid) {
-    if (!accountIdentity.trim() || !accountUuid.trim()) {
-        throw new Error('A verified provider account identity is required');
-    }
-    const base = identityCache.get(accountCacheKey(accountUuid, accountIdentity)) ??
-        getClaudeCodeIdentity(explicitCacheKey(accountIdentity));
-    const identity = { ...base, accountIdentity, accountUuid };
-    cacheAccountIdentity(identity, accountIdentity, accountUuid);
-    return identity;
-}
-export async function resolveClaudeCodeIdentity(accessToken, model, accountIdentity) {
-    const stableAccountIdentity = accountIdentity?.trim() || undefined;
-    const cacheKey = stableAccountIdentity
-        ? explicitCacheKey(stableAccountIdentity)
-        : compatibilityCacheKey(accessToken);
-    let identity;
-    if (stableAccountIdentity) {
-        const cachedIdentity = adoptCachedIdentity(identityCache.get(cacheKey) ?? identityCache.get(accessToken), stableAccountIdentity);
-        identity = cachedIdentity ?? getClaudeCodeIdentity(cacheKey);
-        identity = adoptCachedIdentity(identity, stableAccountIdentity) ?? identity;
-        setBounded(identityCache, cacheKey, identity);
-    }
-    else {
-        identity =
-            identityCache.get(cacheKey) ??
-                identityCache.get(accessToken) ??
-                getClaudeCodeIdentity(cacheKey);
-        setBounded(identityCache, cacheKey, identity);
-        setBounded(identityCache, accessToken, identity);
-    }
-    if (!accessToken.startsWith('sk-ant-oat')) {
-        return clearCachedAccountUuid(cacheKey, identity);
-    }
-    const now = Date.now();
-    // A slot-stable identity survives account replacement; bootstrap is the
-    // account lookup that must be repeated for each credential presented to it.
-    const bootstrapKey = `${cacheKey}:${accessToken}`;
-    const cachedResult = bootstrapResults.get(bootstrapKey);
-    if (cachedResult && cachedResult.expiresAt > now) {
-        if (!cachedResult.accountUuid) {
-            identity = clearCachedAccountUuid(cacheKey, identity);
-            return identity;
-        }
-        if (!stableAccountIdentity) {
-            if (identity.accountUuid === cachedResult.accountUuid)
-                return identity;
-            identity = { ...identity, accountUuid: cachedResult.accountUuid };
-            setBounded(identityCache, bootstrapKey, identity);
-            return identity;
-        }
-        const cachedAccountIdentity = adoptCachedIdentity(identityCache.get(accountCacheKey(cachedResult.accountUuid, stableAccountIdentity)) ?? identityCache.get(`account:${cachedResult.accountUuid}`), stableAccountIdentity, cachedResult.accountUuid);
-        if (cachedAccountIdentity) {
-            identity = cachedAccountIdentity;
-            cacheAccountIdentity(identity, stableAccountIdentity, cachedResult.accountUuid);
-            return identity;
-        }
-        if (identity.accountUuid === cachedResult.accountUuid)
-            return identity;
-        identity = {
-            ...identity,
-            accountIdentity: stableAccountIdentity,
-            accountUuid: cachedResult.accountUuid,
-        };
-        cacheAccountIdentity(identity, stableAccountIdentity, cachedResult.accountUuid);
-        return identity;
-    }
-    let fetchPromise = bootstrapFetches.get(bootstrapKey);
-    if (!fetchPromise) {
-        fetchPromise = fetchClaudeCodeAccountUuid(accessToken, model);
-        setBounded(bootstrapFetches, bootstrapKey, fetchPromise);
-    }
-    const accountUuid = await fetchPromise.finally(() => {
-        if (bootstrapFetches.get(bootstrapKey) === fetchPromise) {
-            bootstrapFetches.delete(bootstrapKey);
-        }
-    });
-    setBounded(bootstrapResults, bootstrapKey, {
-        accountUuid,
-        expiresAt: now +
-            (accountUuid
-                ? BOOTSTRAP_IDENTITY_CACHE_TTL_MS
-                : BOOTSTRAP_IDENTITY_NEGATIVE_TTL_MS),
-    });
-    if (!accountUuid) {
-        identity = clearCachedAccountUuid(cacheKey, identity);
-        return identity;
-    }
-    if (!stableAccountIdentity) {
-        identity = { ...identity, accountUuid };
-        setBounded(identityCache, bootstrapKey, identity);
-        return identity;
-    }
-    const cachedAccountIdentity = adoptCachedIdentity(identityCache.get(accountCacheKey(accountUuid, stableAccountIdentity)) ??
-        identityCache.get(`account:${accountUuid}`), stableAccountIdentity, accountUuid);
-    if (cachedAccountIdentity) {
-        identity = cachedAccountIdentity;
-        cacheAccountIdentity(identity, stableAccountIdentity, accountUuid);
-        return identity;
-    }
-    identity = {
-        ...identity,
-        accountIdentity: stableAccountIdentity,
-        accountUuid,
-    };
-    cacheAccountIdentity(identity, stableAccountIdentity, accountUuid);
-    return identity;
-}
-function isRecord(value) {
-    return value != null && typeof value === 'object' && !Array.isArray(value);
-}
-export function buildClaudeCodeMetadataUserId(identity) {
-    if (!identity.accountUuid)
-        return null;
-    return JSON.stringify({
-        device_id: identity.deviceId,
-        account_uuid: identity.accountUuid,
-        session_id: identity.sessionId,
-    });
-}
-export function applyClaudeCodeMetadata(body, identity) {
-    const userId = buildClaudeCodeMetadataUserId(identity);
-    if (!userId) {
-        if (isRecord(body.metadata))
-            delete body.metadata.user_id;
-        return false;
-    }
-    if (!isRecord(body.metadata))
-        body.metadata = {};
-    const metadata = body.metadata;
-    if (isRecord(metadata))
-        metadata.user_id = userId;
-    return true;
-}
-// Claude Code 2.1.258 sends redact-thinking-2026-02-12, but it suppresses
-// thinking-block content that OpenCode displays; deliberately omitted after A/B proof on 2026-09-01.
-export const CLAUDE_CODE_FULL_AGENT_BETAS = [
-    'oauth-2025-04-20',
-    'interleaved-thinking-2025-05-14',
-    'thinking-token-count-2026-05-13',
-    'context-management-2025-06-27',
-    'prompt-caching-scope-2026-01-05',
-    'claude-code-20250219',
-    'advisor-tool-2026-03-01',
-    'advanced-tool-use-2025-11-20',
-    'mid-conversation-system-2026-04-07',
-    'effort-2025-11-24',
-    'fallback-credit-2026-06-01',
-    'extended-cache-ttl-2025-04-11',
-    'cache-diagnosis-2026-04-07',
-];
-const CLAUDE_CODE_STRUCTURED_OUTPUT_BETAS = [
-    'oauth-2025-04-20',
-    'interleaved-thinking-2025-05-14',
-    'thinking-token-count-2026-05-13',
-    'context-management-2025-06-27',
-    'prompt-caching-scope-2026-01-05',
-    'advisor-tool-2026-03-01',
-    'structured-outputs-2025-12-15',
-    'cache-diagnosis-2026-04-07',
-];
-const CLAUDE_CODE_BASE_BETAS = [
-    'oauth-2025-04-20',
-    'interleaved-thinking-2025-05-14',
-    'thinking-token-count-2026-05-13',
-    'context-management-2025-06-27',
-    'prompt-caching-scope-2026-01-05',
-    'advisor-tool-2026-03-01',
-    'advanced-tool-use-2025-11-20',
-    'extended-cache-ttl-2025-04-11',
-    'cache-diagnosis-2026-04-07',
-];
-function hasStructuredOutput(body) {
-    const outputConfig = body.output_config;
-    const format = outputConfig?.format;
-    return format?.type === 'json_schema';
-}
-function hasFullAgentShape(body) {
-    return (Array.isArray(body.tools) &&
-        body.tools.length > 0 &&
-        Array.isArray(body.system) &&
-        isRecord(body.thinking) &&
-        isRecord(body.context_management) &&
-        isRecord(body.output_config) &&
-        isRecord(body.diagnostics));
-}
-export function selectClaudeCodeBetas(body, extraBetas = []) {
-    const selected = body
-        ? hasFullAgentShape(body)
-            ? [...CLAUDE_CODE_FULL_AGENT_BETAS]
-            : hasStructuredOutput(body)
-                ? [...CLAUDE_CODE_STRUCTURED_OUTPUT_BETAS]
-                : [...CLAUDE_CODE_BASE_BETAS]
-        : [...CLAUDE_CODE_BASE_BETAS];
-    if (body?.speed === 'fast')
-        selected.push(FAST_MODE_BETA);
-    for (const beta of extraBetas) {
-        const trimmed = beta.trim();
-        if (trimmed)
-            selected.push(trimmed);
-    }
-    return [...new Set(selected)].join(',');
-}
-function stainlessOS() {
-    switch (process.platform) {
-        case 'darwin':
-            return 'MacOS';
-        case 'win32':
-            return 'Windows';
-        case 'linux':
-            return 'Linux';
-        case 'freebsd':
-            return 'FreeBSD';
-        default:
-            return 'Unknown';
-    }
-}
-function stainlessArch() {
-    switch (process.arch) {
-        case 'arm64':
-            return 'arm64';
-        case 'x64':
-            return 'x64';
-        case 'ia32':
-            return 'x32';
-        default:
-            return process.arch;
-    }
-}
-export function applyClaudeCodeHeaders(headers, accessToken, options = {}) {
-    const identity = options.identity ?? getClaudeCodeIdentity(accessToken);
-    const incomingBetas = (headers.get('anthropic-beta') ?? '')
-        .split(',')
-        .map((beta) => beta.trim())
-        .filter(Boolean);
-    const extraBetas = [...incomingBetas, ...(options.extraBetas ?? [])];
-    headers.set('accept', 'application/json');
-    headers.set('authorization', `Bearer ${accessToken}`);
-    headers.set('content-type', 'application/json');
-    headers.set('user-agent', USER_AGENT);
-    headers.set('anthropic-beta', selectClaudeCodeBetas(options.body, extraBetas));
-    headers.set('anthropic-dangerous-direct-browser-access', 'true');
-    headers.set('anthropic-version', '2023-06-01');
-    headers.set('x-app', 'cli');
-    headers.set('x-client-request-id', randomUUID());
-    headers.set('x-claude-code-session-id', identity.sessionId);
-    headers.set('x-stainless-arch', stainlessArch());
-    headers.set('x-stainless-lang', 'js');
-    headers.set('x-stainless-os', stainlessOS());
-    headers.set('x-stainless-package-version', CLAUDE_CODE_STAINLESS_PACKAGE_VERSION);
-    headers.set('x-stainless-retry-count', '0');
-    headers.set('x-stainless-runtime', 'node');
-    headers.set('x-stainless-runtime-version', CLAUDE_CODE_STAINLESS_RUNTIME_VERSION);
-    headers.set('x-stainless-timeout', '600');
-    headers.delete('x-api-key');
-    return headers;
-}
-const BODY_FIELD_ORDER = [
-    'model',
-    'messages',
-    'system',
-    'tools',
-    'tool_choice',
-    'metadata',
-    'max_tokens',
-    'temperature',
-    'thinking',
-    'context_management',
-    'output_config',
-    'diagnostics',
-    'stream',
-    'speed',
-];
-export function orderClaudeCodeBody(body) {
-    const ordered = {};
-    for (const key of BODY_FIELD_ORDER) {
-        if (Object.hasOwn(body, key))
-            ordered[key] = body[key];
-    }
-    for (const [key, value] of Object.entries(body)) {
-        if (!Object.hasOwn(ordered, key))
-            ordered[key] = value;
-    }
-    return ordered;
-}
-export function claudeCodeEntrypoint() {
-    return CLAUDE_CODE_ENTRYPOINT;
-}

package/dist/claustrum-enrollment-registry.d.ts

@@ -1,17 +0,0 @@
-import { type ClaustrumEnrollmentConnection, type ClaustrumEnrollmentPaths, type ClaustrumEnrollmentStatus } from './claustrum-enrollment.js';
-export declare function getHostClaustrumEnrollmentPaths(host: 'opencode' | 'pi', env?: NodeJS.ProcessEnv, cwd?: string): ClaustrumEnrollmentPaths;
-export interface ClaustrumEnrollmentAdoption {
-    status(): ClaustrumEnrollmentStatus;
-    reconcileNow(): Promise<void>;
-    resetTerminal(): Promise<'reset' | 'idle' | 'refused-pending' | 'refused-approved' | 'busy'>;
-    release(): void;
-}
-export declare function adoptClaustrumEnrollment(options: {
-    proposedName: string;
-    paths: ClaustrumEnrollmentPaths;
-    connect: () => Promise<ClaustrumEnrollmentConnection>;
-    onStatus?: (status: ClaustrumEnrollmentStatus) => void;
-    setTimeoutImpl?: typeof setTimeout;
-    clearTimeoutImpl?: typeof clearTimeout;
-    pollIntervalMs?: number;
-}): ClaustrumEnrollmentAdoption;