@cortexkit/anthropic-auth-core 1.22.0 → 1.23.0

package/dist/claustrum-enrollment.d.ts

@@ -0,0 +1,70 @@
+import { type ClaustrumClientOptions as ClaustrumEnrollmentClientOptions, type EnrollmentPollOutcome, type EnrollmentTokenFile, writeEnrollmentTokenFile } from '@cortexkit/claustrum-client';
+export declare const CLAUSTRUM_OPENCODE_ENROLLMENT_NAME = "anthropic-auth-opencode";
+export declare const CLAUSTRUM_PI_ENROLLMENT_NAME = "anthropic-auth-pi";
+export interface ClaustrumEnrollmentClient {
+    enrollPropose(input: {
+        name: string;
+        requestSecretHash: string;
+    }): Promise<{
+        requestId: string;
+    }>;
+    enrollPoll(input: {
+        requestId: string;
+        requestSecret: string;
+    }): Promise<EnrollmentPollOutcome>;
+}
+export interface ClaustrumEnrollmentConnection extends ClaustrumEnrollmentClient {
+    close(): void;
+}
+export declare function connectClaustrumEnrollmentClient(options?: ClaustrumEnrollmentClientOptions): Promise<ClaustrumEnrollmentConnection>;
+export type ClaustrumEnrollmentStatus = {
+    state: 'idle';
+} | {
+    state: 'pending';
+    proposedName: string;
+    requestId?: string;
+    retryCode?: string;
+} | {
+    state: 'approved';
+    proposedName: string;
+    approvedName?: string;
+    tokenGeneration: number;
+} | {
+    state: 'denied';
+    proposedName: string;
+} | {
+    state: 'blocked';
+    proposedName: string;
+    code: string;
+} | {
+    state: 'unavailable';
+    proposedName: string;
+    code: string;
+} | {
+    state: 'busy';
+};
+export interface ClaustrumEnrollmentPaths {
+    statePath: string;
+    tokenPath: string;
+}
+export declare function getClaustrumEnrollmentPaths(tokenPath: string): ClaustrumEnrollmentPaths;
+export declare function readClaustrumEnrollmentStatus(paths: ClaustrumEnrollmentPaths, proposedName?: string): Promise<ClaustrumEnrollmentStatus>;
+/** Read fresh bearer material for a scoped operation; never publish this value. */
+export declare function readClaustrumEnrollmentToken(tokenPath: string): Promise<EnrollmentTokenFile>;
+export declare class ClaustrumEnrollmentManager {
+    #private;
+    constructor(options: {
+        client: ClaustrumEnrollmentClient;
+        paths: ClaustrumEnrollmentPaths;
+        proposedName: string;
+        now?: () => number;
+        mintSecret?: () => string;
+        writeTokenFile?: typeof writeEnrollmentTokenFile;
+    });
+    status(): Promise<ClaustrumEnrollmentStatus>;
+    resetTerminal(): Promise<ClaustrumEnrollmentResetResult>;
+    reconcile(): Promise<ClaustrumEnrollmentStatus>;
+}
+export type ClaustrumEnrollmentResetResult = 'reset' | 'idle' | 'refused-pending' | 'refused-approved' | 'busy';
+/** Reset local terminal metadata without connecting to the credential daemon. */
+export declare function resetClaustrumEnrollmentState(paths: ClaustrumEnrollmentPaths, proposedName: string): Promise<ClaustrumEnrollmentResetResult>;

package/dist/claustrum-enrollment.js

@@ -0,0 +1,485 @@
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
+import { constants as fsConstants } from 'node:fs';
+import { chmod, mkdir, open, realpath, rename, stat, unlink, } from 'node:fs/promises';
+import { basename, dirname, extname, join } from 'node:path';
+import { ClaustrumCredentialError, ClaustrumClient as ClaustrumWireClient, writeEnrollmentTokenFile, } from '@cortexkit/claustrum-client';
+import { acquireRefreshFileLock } from './accounts.js';
+import { parseJsonRedacted } from './json.js';
+export const CLAUSTRUM_OPENCODE_ENROLLMENT_NAME = 'anthropic-auth-opencode';
+export const CLAUSTRUM_PI_ENROLLMENT_NAME = 'anthropic-auth-pi';
+const ENROLLMENT_SCHEMA = 1;
+const ENROLLMENT_FILE_MAX_BYTES = 16 * 1024;
+const ENROLLMENT_LOCK_TTL_MS = 30_000;
+const TOKEN_RE = /^[0-9a-f]{64}$/;
+export function connectClaustrumEnrollmentClient(options = {}) {
+    return ClaustrumWireClient.connect(options);
+}
+export function getClaustrumEnrollmentPaths(tokenPath) {
+    const extension = extname(tokenPath) || '.json';
+    const stem = basename(tokenPath, extname(tokenPath));
+    return {
+        statePath: join(dirname(tokenPath), `${stem}-state${extension}`),
+        tokenPath,
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function validTimestamp(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+function validGeneration(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 1;
+}
+function decodeEnrollmentState(value) {
+    if (!isRecord(value) ||
+        value.version !== ENROLLMENT_SCHEMA ||
+        typeof value.proposedName !== 'string' ||
+        value.proposedName.length === 0) {
+        throw new Error('invalid Claustrum enrollment state');
+    }
+    if (value.phase === 'pending') {
+        if (!TOKEN_RE.test(String(value.requestSecret ?? '')) ||
+            (value.requestId !== undefined &&
+                (typeof value.requestId !== 'string' ||
+                    value.requestId.length === 0)) ||
+            !validTimestamp(value.createdAt) ||
+            !validTimestamp(value.updatedAt)) {
+            throw new Error('invalid Claustrum enrollment state');
+        }
+        return {
+            version: 1,
+            phase: 'pending',
+            proposedName: value.proposedName,
+            requestSecret: value.requestSecret,
+            ...(value.requestId !== undefined && {
+                requestId: value.requestId,
+            }),
+            createdAt: value.createdAt,
+            updatedAt: value.updatedAt,
+        };
+    }
+    if (value.phase === 'approved') {
+        if ((value.approvedName !== undefined &&
+            (typeof value.approvedName !== 'string' ||
+                value.approvedName.length === 0)) ||
+            !validGeneration(value.tokenGeneration) ||
+            !validTimestamp(value.updatedAt)) {
+            throw new Error('invalid Claustrum enrollment state');
+        }
+        return {
+            version: 1,
+            phase: 'approved',
+            proposedName: value.proposedName,
+            ...(value.approvedName !== undefined && {
+                approvedName: value.approvedName,
+            }),
+            tokenGeneration: value.tokenGeneration,
+            updatedAt: value.updatedAt,
+        };
+    }
+    if (value.phase === 'denied' || value.phase === 'blocked') {
+        if ((value.errorCode !== undefined && typeof value.errorCode !== 'string') ||
+            !validTimestamp(value.updatedAt)) {
+            throw new Error('invalid Claustrum enrollment state');
+        }
+        return {
+            version: 1,
+            phase: value.phase,
+            proposedName: value.proposedName,
+            ...(value.errorCode !== undefined && {
+                errorCode: value.errorCode,
+            }),
+            updatedAt: value.updatedAt,
+        };
+    }
+    throw new Error('invalid Claustrum enrollment state');
+}
+function decodeTokenFile(value) {
+    if (!isRecord(value) ||
+        !TOKEN_RE.test(String(value.token ?? '')) ||
+        !validGeneration(value.token_generation)) {
+        throw new Error('invalid Claustrum enrollment token file');
+    }
+    return {
+        token: value.token,
+        token_generation: value.token_generation,
+    };
+}
+function validateReadableSecretFile(metadata) {
+    if (!metadata.isFile()) {
+        throw new Error('Claustrum enrollment file must be a regular file');
+    }
+    if ((metadata.mode & 0o077) !== 0) {
+        throw new Error('Claustrum enrollment file must be owner-only');
+    }
+    const expectedUid = process.getuid?.();
+    if (expectedUid !== undefined && metadata.uid !== expectedUid) {
+        throw new Error('Claustrum enrollment file must be owned by the current user');
+    }
+}
+async function readBoundedJson(path) {
+    let descriptor;
+    try {
+        descriptor = await open(path, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw new Error('Claustrum enrollment file could not be opened safely');
+    }
+    try {
+        validateReadableSecretFile(await descriptor.stat());
+        const source = Buffer.alloc(ENROLLMENT_FILE_MAX_BYTES + 1);
+        const { bytesRead } = await descriptor.read(source, 0, source.byteLength, 0);
+        if (bytesRead > ENROLLMENT_FILE_MAX_BYTES) {
+            throw new Error('Claustrum enrollment file is too large');
+        }
+        return parseJsonRedacted(source.subarray(0, bytesRead).toString('utf8'));
+    }
+    finally {
+        await descriptor.close();
+    }
+}
+async function refuseWritableAncestor(parent) {
+    let component;
+    try {
+        component = await realpath(parent);
+    }
+    catch {
+        return;
+    }
+    for (;;) {
+        const metadata = await stat(component).catch(() => undefined);
+        if (metadata &&
+            (metadata.mode & 0o022) !== 0 &&
+            (metadata.mode & 0o1000) === 0) {
+            throw new Error('Claustrum enrollment path has an unsafe writable ancestor');
+        }
+        const next = dirname(component);
+        if (next === component)
+            return;
+        component = next;
+    }
+}
+async function writeStateAtomic(path, state) {
+    const parent = dirname(path);
+    await mkdir(parent, { recursive: true, mode: 0o700 });
+    await refuseWritableAncestor(parent);
+    const bytes = `${JSON.stringify(state)}\n`;
+    if (Buffer.byteLength(bytes) > ENROLLMENT_FILE_MAX_BYTES) {
+        throw new Error('Claustrum enrollment state is too large');
+    }
+    const temporary = join(parent, `.${basename(path)}.${process.pid}.${randomUUID()}.tmp`);
+    let descriptor;
+    try {
+        descriptor = await open(temporary, 'wx', 0o600);
+        await descriptor.writeFile(bytes, 'utf8');
+        await descriptor.sync();
+        await descriptor.close();
+        descriptor = undefined;
+        await chmod(temporary, 0o600);
+        await rename(temporary, path);
+    }
+    finally {
+        await descriptor?.close().catch(() => { });
+        await unlink(temporary).catch(() => { });
+    }
+}
+export async function readClaustrumEnrollmentStatus(paths, proposedName = CLAUSTRUM_OPENCODE_ENROLLMENT_NAME) {
+    const tokenValue = await readBoundedJson(paths.tokenPath);
+    const token = tokenValue === undefined ? undefined : decodeTokenFile(tokenValue);
+    const stateValue = await readBoundedJson(paths.statePath);
+    const state = stateValue === undefined ? undefined : decodeEnrollmentState(stateValue);
+    if (token) {
+        return {
+            state: 'approved',
+            proposedName: state?.proposedName ?? proposedName,
+            ...(state?.phase === 'approved' &&
+                state.approvedName !== undefined && {
+                approvedName: state.approvedName,
+            }),
+            tokenGeneration: token.token_generation,
+        };
+    }
+    if (!state)
+        return { state: 'idle' };
+    if (state.phase === 'pending') {
+        return {
+            state: 'pending',
+            proposedName: state.proposedName,
+            ...(state.requestId !== undefined && { requestId: state.requestId }),
+        };
+    }
+    if (state.phase === 'approved') {
+        return {
+            state: 'blocked',
+            proposedName: state.proposedName,
+            code: 'missing_token',
+        };
+    }
+    if (state.phase === 'denied')
+        return { state: 'denied', proposedName: state.proposedName };
+    return {
+        state: 'blocked',
+        proposedName: state.proposedName,
+        code: state.errorCode ?? 'unknown',
+    };
+}
+/** Read fresh bearer material for a scoped operation; never publish this value. */
+export async function readClaustrumEnrollmentToken(tokenPath) {
+    await refuseWritableAncestor(tokenPath);
+    const value = await readBoundedJson(tokenPath);
+    if (value === undefined)
+        throw new Error('Claustrum enrollment is not configured');
+    return decodeTokenFile(value);
+}
+function statusFromState(state) {
+    if (state.phase === 'pending') {
+        return {
+            state: 'pending',
+            proposedName: state.proposedName,
+            ...(state.requestId !== undefined && { requestId: state.requestId }),
+        };
+    }
+    if (state.phase === 'approved') {
+        return {
+            state: 'approved',
+            proposedName: state.proposedName,
+            ...(state.approvedName !== undefined && {
+                approvedName: state.approvedName,
+            }),
+            tokenGeneration: state.tokenGeneration,
+        };
+    }
+    if (state.phase === 'denied')
+        return { state: 'denied', proposedName: state.proposedName };
+    return {
+        state: 'blocked',
+        proposedName: state.proposedName,
+        code: state.errorCode ?? 'unknown',
+    };
+}
+export class ClaustrumEnrollmentManager {
+    #client;
+    #paths;
+    #proposedName;
+    #now;
+    #mintSecret;
+    #writeTokenFile;
+    constructor(options) {
+        this.#client = options.client;
+        this.#paths = options.paths;
+        this.#proposedName = options.proposedName;
+        this.#now = options.now ?? Date.now;
+        this.#mintSecret =
+            options.mintSecret ?? (() => randomBytes(32).toString('hex'));
+        this.#writeTokenFile = options.writeTokenFile ?? writeEnrollmentTokenFile;
+    }
+    async status() {
+        return readClaustrumEnrollmentStatus(this.#paths, this.#proposedName);
+    }
+    async resetTerminal() {
+        return resetClaustrumEnrollmentState(this.#paths, this.#proposedName);
+    }
+    async reconcile() {
+        await mkdir(dirname(this.#paths.statePath), {
+            recursive: true,
+            mode: 0o700,
+        });
+        const lock = await acquireRefreshFileLock({
+            name: 'ceremony',
+            path: this.#paths.statePath,
+            ttlMs: ENROLLMENT_LOCK_TTL_MS,
+            renew: true,
+        });
+        if (!lock)
+            return { state: 'busy' };
+        try {
+            const existingToken = await readBoundedJson(this.#paths.tokenPath);
+            const token = existingToken === undefined ? undefined : decodeTokenFile(existingToken);
+            const stateValue = await readBoundedJson(this.#paths.statePath);
+            let state = stateValue === undefined ? undefined : decodeEnrollmentState(stateValue);
+            if (state && state.proposedName !== this.#proposedName) {
+                throw new Error('Claustrum enrollment state belongs to a different consumer');
+            }
+            if (token) {
+                if (!state || state.phase === 'pending') {
+                    const approved = {
+                        version: 1,
+                        phase: 'approved',
+                        proposedName: state?.proposedName ?? this.#proposedName,
+                        tokenGeneration: token.token_generation,
+                        updatedAt: this.#now(),
+                    };
+                    await writeStateAtomic(this.#paths.statePath, approved);
+                    state = approved;
+                }
+                return {
+                    state: 'approved',
+                    proposedName: state.proposedName,
+                    ...(state.phase === 'approved' &&
+                        state.approvedName !== undefined && {
+                        approvedName: state.approvedName,
+                    }),
+                    tokenGeneration: token.token_generation,
+                };
+            }
+            if (state?.phase === 'approved') {
+                const blocked = {
+                    version: 1,
+                    phase: 'blocked',
+                    proposedName: state.proposedName,
+                    errorCode: 'missing_token',
+                    updatedAt: this.#now(),
+                };
+                await writeStateAtomic(this.#paths.statePath, blocked);
+                return statusFromState(blocked);
+            }
+            if (state && state.phase !== 'pending')
+                return statusFromState(state);
+            if (!state) {
+                const now = this.#now();
+                state = {
+                    version: 1,
+                    phase: 'pending',
+                    proposedName: this.#proposedName,
+                    requestSecret: this.#mintSecret(),
+                    createdAt: now,
+                    updatedAt: now,
+                };
+                if (!TOKEN_RE.test(state.requestSecret))
+                    throw new Error('invalid minted Claustrum enrollment secret');
+                await writeStateAtomic(this.#paths.statePath, state);
+            }
+            if (!state.requestId) {
+                try {
+                    const requestSecretHash = createHash('sha256')
+                        .update(Buffer.from(state.requestSecret, 'hex'))
+                        .digest('hex');
+                    const proposed = await this.#client.enrollPropose({
+                        name: state.proposedName,
+                        requestSecretHash,
+                    });
+                    state = {
+                        ...state,
+                        requestId: proposed.requestId,
+                        updatedAt: this.#now(),
+                    };
+                    await writeStateAtomic(this.#paths.statePath, state);
+                }
+                catch (error) {
+                    if (error instanceof ClaustrumCredentialError) {
+                        if (error.code === 'pending_queue_full' ||
+                            error.action === 'retry') {
+                            return {
+                                state: 'pending',
+                                proposedName: state.proposedName,
+                                retryCode: error.code,
+                            };
+                        }
+                        const blocked = {
+                            version: 1,
+                            phase: 'blocked',
+                            proposedName: state.proposedName,
+                            errorCode: error.code,
+                            updatedAt: this.#now(),
+                        };
+                        await writeStateAtomic(this.#paths.statePath, blocked);
+                        return statusFromState(blocked);
+                    }
+                    throw error;
+                }
+            }
+            const requestId = state.requestId;
+            if (!requestId)
+                return statusFromState(state);
+            try {
+                const outcome = await this.#client.enrollPoll({
+                    requestId,
+                    requestSecret: state.requestSecret,
+                });
+                if (outcome.status === 'pending')
+                    return statusFromState(state);
+                if (outcome.status === 'denied') {
+                    const denied = {
+                        version: 1,
+                        phase: 'denied',
+                        proposedName: state.proposedName,
+                        updatedAt: this.#now(),
+                    };
+                    await writeStateAtomic(this.#paths.statePath, denied);
+                    return statusFromState(denied);
+                }
+                await this.#writeTokenFile(this.#paths.tokenPath, {
+                    token: outcome.token,
+                    token_generation: outcome.tokenGeneration,
+                });
+                const approved = {
+                    version: 1,
+                    phase: 'approved',
+                    proposedName: state.proposedName,
+                    approvedName: outcome.name,
+                    tokenGeneration: outcome.tokenGeneration,
+                    updatedAt: this.#now(),
+                };
+                await writeStateAtomic(this.#paths.statePath, approved);
+                return statusFromState(approved);
+            }
+            catch (error) {
+                if (!(error instanceof ClaustrumCredentialError))
+                    throw error;
+                if (error.action === 'retry') {
+                    return {
+                        state: 'pending',
+                        proposedName: state.proposedName,
+                        requestId,
+                        retryCode: error.code,
+                    };
+                }
+                const blocked = {
+                    version: 1,
+                    phase: 'blocked',
+                    proposedName: state.proposedName,
+                    errorCode: error.code,
+                    updatedAt: this.#now(),
+                };
+                await writeStateAtomic(this.#paths.statePath, blocked);
+                return statusFromState(blocked);
+            }
+        }
+        finally {
+            await lock.release();
+        }
+    }
+}
+/** Reset local terminal metadata without connecting to the credential daemon. */
+export async function resetClaustrumEnrollmentState(paths, proposedName) {
+    await mkdir(dirname(paths.statePath), { recursive: true, mode: 0o700 });
+    const lock = await acquireRefreshFileLock({
+        name: 'ceremony',
+        path: paths.statePath,
+        ttlMs: ENROLLMENT_LOCK_TTL_MS,
+        renew: true,
+    });
+    if (!lock)
+        return 'busy';
+    try {
+        if ((await readBoundedJson(paths.tokenPath)) !== undefined)
+            return 'refused-approved';
+        const value = await readBoundedJson(paths.statePath);
+        if (value === undefined)
+            return 'idle';
+        const state = decodeEnrollmentState(value);
+        if (state.proposedName !== proposedName)
+            throw new Error('Claustrum enrollment state belongs to a different consumer');
+        if (state.phase === 'pending')
+            return 'refused-pending';
+        await lock.assertOwned();
+        await unlink(paths.statePath);
+        return 'reset';
+    }
+    finally {
+        await lock.release();
+    }
+}

package/dist/claustrum-scoped-roster.d.ts

@@ -0,0 +1,23 @@
+import { type AccountStorage, type OAuthAccount } from './accounts.js';
+import type { ClaustrumScopedAccount, ClaustrumScopedCustody } from './claustrum-scoped.js';
+export interface ClaustrumScopedRoster {
+    /** The vault's conventional default record; absent when only labeled accounts exist. */
+    primary?: ClaustrumScopedAccount;
+    accounts: readonly OAuthAccount[];
+    storage: AccountStorage;
+    view: string;
+}
+/** Pure identity projection; callers must serialize discovery before persisting it. */
+export declare function projectClaustrumScopedRoster(storage: AccountStorage, rows: readonly ClaustrumScopedAccount[], view: string, now?: number): ClaustrumScopedRoster;
+/**
+ * The lease covers LIST and commit, not just the file write: opaque view hashes
+ * cannot tell a delayed old response from a newer one. A lost lease is checked
+ * while holding the config lock, before any authoritative membership write.
+ * Neither local mode nor a failed list can publish an empty inventory.
+ */
+export declare function refreshClaustrumScopedRoster(options: {
+    path: string;
+    custody: Pick<ClaustrumScopedCustody, 'discover'>;
+    signal?: AbortSignal;
+    now?: () => number;
+}): Promise<ClaustrumScopedRoster | undefined>;