@cortexkit/anthropic-auth-core 2.3.0 → 2.4.1

package/dist/accounts.d.ts

@@ -311,6 +311,8 @@ export type AccountStateSaveScope = {
     accounts?: true | string[];
 };
 export declare const FALLBACK_BACKGROUND_TICK_MS = 60000;
+/** OpenCode's config folder, as OpenCode itself resolves it. */
+export declare function getOpenCodeConfigDir(env?: NodeJS.ProcessEnv, home?: string): string;
 export declare function getAccountStoragePath(): string;
 export declare function getAccountStatePath(configPath?: string): string;
 export declare function createEmptyStorage(): AccountStorage;

package/dist/cachekeep.d.ts

@@ -149,6 +149,12 @@ export declare class CacheKeepManager {
         oauthAccountId?: string;
     } | undefined;
     trackedCount(): number;
+    /**
+     * Drop targets whose cache has already expired, without sending or
+     * publishing anything. Returns the earliest expiry among the targets that
+     * remain, or undefined when none remain.
+     */
+    dropExpiredTargets(now?: number): number | undefined;
     private publishTrackedSessions;
     private totalBodyBytes;
     private evictOldestTarget;

package/dist/holder-registry.d.ts

@@ -0,0 +1,159 @@
+import { type NativeLockEvent } from './native-lock-observer.ts';
+import type { NativePoolPaths } from './pool-paths.ts';
+import { RelocatedError } from './relocation-guard.ts';
+/** The file, beside a dataset's files, that lists the processes using them. */
+export declare const HOLDER_FILE_NAME = "anthropic-auth-holders.json";
+/** Lock name on the holder file: lock file `<holder file>.holders.lock`. */
+export declare const HOLDER_LOCK_NAME = "holders";
+/**
+ * How long a registrant waits for the holder lock. A process moving or
+ * restoring state holds it for the whole transition; an ordinary registrant
+ * holds it for one small read and write.
+ */
+export declare const HOLDER_LOCK_TIMEOUT_MS = 120000;
+/** At most one retry a minute after a failed ordinary registration. */
+export declare const HOLDER_RETRY_INTERVAL_MS = 60000;
+/**
+ * Where a registered process keeps the dataset: `legacy` beside OpenCode's
+ * account files; `explicit` beside files named by a path override; `pi`
+ * beside Pi's files. `state-home` is written by later releases only, which
+ * keep moved state under the CortexKit state folder.
+ */
+export type HolderKind = 'legacy' | 'explicit' | 'pi' | 'state-home';
+/** Which kind of process registered. */
+export type HolderRole = 'opencode1' | 'opencode2' | 'cli' | 'setup' | 'pi';
+/** One process's use of one dataset, as recorded in a holder file. */
+export interface HolderEntry {
+    readonly pid: number;
+    /**
+     * A value the OS fixes for the life of the process (Linux boot id and start
+     * ticks; macOS start time), or null where none is read (Windows). It tells a
+     * reused pid from the process that registered.
+     */
+    readonly incarnation: string | null;
+    /** Distinguishes copies of this code loaded into the same process. */
+    readonly instance: string;
+    readonly role: HolderRole;
+    readonly release: string;
+    readonly kind: HolderKind;
+    /** The config folder's identity for `legacy`, otherwise null. */
+    readonly identity: string | null;
+    /** Canonical paths of every dataset file the process uses. */
+    readonly files: readonly string[];
+    readonly registeredAt: number;
+}
+/** Added to pid artifacts written by this version and later, so a newer version can tell them from those of older versions. */
+export interface WriterStamp {
+    readonly protocol: 1;
+    readonly release: string;
+}
+/**
+ * This code's release, read once from the package.json one folder above the
+ * running module (the same in a source checkout and in each published
+ * package, whose versions are kept equal). `unknown` when it can't be read.
+ */
+export declare function anthropicAuthRelease(): string;
+/**
+ * The `writer` field this version adds to RPC port files and CacheKeep records.
+ * Older readers copy only the fields they know, so they ignore it.
+ */
+export declare function writerStamp(): WriterStamp;
+/**
+ * Every file of a dataset that a later release may move: local pool state,
+ * local runtime, journal, local custody roster, vault store state, vault
+ * runtime, vault roster and vault routing, sorted.
+ */
+export declare function nativeHolderDatasetFiles(paths: NativePoolPaths): string[];
+/**
+ * A directory a later release may move state into: its path ends in
+ * `cortexkit/anthropic-auth/opencode` or `cortexkit/anthropic-auth/opencode-`
+ * followed by 16 hex digits, under any state root.
+ */
+export declare function isDestinationShapedDirectory(dir: string): boolean;
+/** OpenCode's dataset is `explicit` when a path override names its files. */
+export declare function openCodeHolderKind(env?: NodeJS.ProcessEnv): 'legacy' | 'explicit';
+export type HolderRegistrationErrorCode = 'lock-timeout' | 'managed-folder' | 'malformed' | 'unavailable';
+/**
+ * A registration that must succeed did not, or a path override points into
+ * a folder anthropic-auth manages. The message is fixed; `directory` and the
+ * cause carry the details for logs and diagnostics.
+ */
+export declare class HolderRegistrationError extends Error {
+    readonly code: HolderRegistrationErrorCode;
+    readonly directory: string;
+    constructor(code: HolderRegistrationErrorCode, directory: string, cause?: unknown);
+}
+/** Every fixed message `HolderRegistrationError` can carry. */
+export declare const HOLDER_REGISTRATION_ERROR_MESSAGES: readonly string[];
+/**
+ * The relocation or registration refusal behind `error`, if any. Pool and
+ * roster operations wrap what their hooks throw in their own error, which
+ * keeps the original as its `cause`, so the chain is followed a few levels.
+ */
+export declare function stateRefusalCause(error: unknown): RelocatedError | HolderRegistrationError | undefined;
+/** How liveness is read; tests replace it. */
+export interface HolderLiveness {
+    pidAlive(pid: number): boolean;
+    /** Undefined or null when it can't be read. */
+    incarnation(pid: number): Promise<string | null>;
+}
+/** The OS's fixed per-process value for `pid`, or null when none is read. */
+export declare function processIncarnation(pid: number): Promise<string | null>;
+/**
+ * Whether an entry's process may still be running. A dead pid is stale. A
+ * live pid is stale only when the entry recorded an incarnation and the OS
+ * now reports a different one; an unreadable incarnation counts as alive.
+ * So pid reuse can keep a stale entry, but never clears a live one.
+ */
+export declare function holderEntryIsLive(entry: Pick<HolderEntry, 'pid' | 'incarnation'>, liveness?: HolderLiveness): Promise<boolean>;
+export interface RegisterNativePoolHolderOptions {
+    paths: NativePoolPaths;
+    role: HolderRole;
+    /** `legacy` or `explicit` for OpenCode (see `openCodeHolderKind`); `pi` for Pi. */
+    kind: Exclude<HolderKind, 'state-home'>;
+    /** Observes the holder locks, as other native lock observers do. */
+    onLockEvent?: (event: NativeLockEvent) => void;
+    /** Tests shorten these; production uses the defaults. */
+    lockTimeoutMs?: number;
+    retryIntervalMs?: number;
+    liveness?: HolderLiveness;
+    now?: () => number;
+}
+/** The outcome of a registration that did not refuse. */
+export interface NativeHolderRegistration {
+    /**
+     * `registered` once every holder file lists this process. `pending` while
+     * an ordinary registration keeps failing; it is retried in the background
+     * at most once a minute until it succeeds or `close()` is called.
+     */
+    readonly status: 'registered' | 'pending';
+    /** Resolves once a pending registration has been retried successfully. */
+    readonly settled: Promise<void>;
+    /** Stop retrying. Published entries stay; later writers prune them once the pid is dead. */
+    close(): void;
+}
+/**
+ * Record, beside a dataset's files, that this process uses them, before the
+ * process's first pool I/O for that dataset. A later release reads these
+ * records and never moves a dataset that a live process still uses.
+ *
+ * Refuses, whatever the outcome of the write, when either legacy runtime file
+ * is a relocation tombstone (`RelocatedError`), or when an `explicit` or `pi`
+ * dataset lies in a folder anthropic-auth manages (`HolderRegistrationError`
+ * with `managed-folder`).
+ *
+ * A failed write is handled by kind:
+ * - An `explicit` or `pi` dataset with a file in a destination-shaped folder
+ *   (see `isDestinationShapedDirectory`) must be registered there, so the
+ *   call throws `HolderRegistrationError` and the process must not serve it.
+ * - Every other dataset is served as before: the failure is logged once at
+ *   WARN and retried in the background at most once a minute. Such a
+ *   process also records itself in a folder only once one of its dataset
+ *   files exists there; until then the same retry checks again.
+ *
+ * Call it holding no data lock: a mover holds the holder lock while it waits
+ * for data locks.
+ */
+export declare function registerNativePoolHolder(options: RegisterNativePoolHolderOptions): Promise<NativeHolderRegistration>;
+/** Forget what this process has published; tests only. */
+export declare function resetNativeHolderRegistryForTests(): void;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export type { CommandResult, CommandRunner, HostDetection, OpenCodeGeneration, ProcessFence, SetupCallbackContext, SetupDetection, SetupEnvironment, SetupFileSystem, SetupHost, SetupIO, SetupPlugin, SetupResult, } from "./internal-types/setup/index.js";
-export { assertHostsStopped, createProcessFence, runSetup, setupEnrollment, } from "./internal-types/setup/index.js";
+export { assertHostsStopped, createProcessFence, runSetup, setupEnrollment, setupUsage, } from "./internal-types/setup/index.js";
 export * from './accounts.ts';
 export * from './auth.ts';
 export * from './cache1h.ts';
@@ -14,6 +14,7 @@ export * from './constants.ts';
 export * from './custom-headers.ts';
 export * from './dump.ts';
 export * from './fast.ts';
+export * from './holder-registry.ts';
 export * from './json.ts';
 export * from './killswitch.ts';
 export * from './logger.ts';
@@ -81,12 +82,14 @@ export * from './quota-headers.ts';
 export * from './quota-manager.ts';
 export * from './quotas.ts';
 export * from './relay.ts';
+export * from './relocation-guard.ts';
 export * from './request-gzip.ts';
 export * from './request-history.ts';
 export * from './routing.ts';
 export type { SseEvent, SseFramer, SseFramerOptions } from './sse.ts';
 export { createSseFramer, DEFAULT_SSE_MAX_FRAME_BYTES, decodeSseFrame, isSseCandidateFrame, isTerminatedSseFrame, parseSseFrame, SseFrameTooLargeError, } from './sse.ts';
 export * from './start.ts';
+export * from './state-layout-paths.ts';
 export * from './sticky-routing.ts';
 export * from './thinking-binding.ts';
 export * from './turn-end-note.ts';