@cortexkit/anthropic-auth-core 2.0.1 → 2.0.3

package/dist/native-quota-observations.d.ts

@@ -0,0 +1,26 @@
+import { type AccountStorage, type OAuthQuotaSnapshot } from './accounts.ts';
+import type { NativeLocalPoolBinding } from './pool-binding.ts';
+import type { QuotaEntry } from './quota-manager.ts';
+export type NativeQuotaObservation = {
+    lineage: string;
+    accountUuid: string;
+    entry: QuotaEntry;
+    generalExhausted: boolean;
+    quotaErrorClearedAt?: number;
+};
+export declare function nativePollQuotaGenerallyExhausted(quota: OAuthQuotaSnapshot): boolean;
+export declare function nativeLocalQuotaLineage(binding: NativeLocalPoolBinding & {
+    readonly identity: string;
+}): string;
+export declare function nativeLocalQuotaLineage(binding: NativeLocalPoolBinding | undefined): string | undefined;
+/** Shared by header receipt, poll completion, routing and display; contains no credentials. */
+export declare class NativeQuotaObservations extends Map<string, NativeQuotaObservation> {
+    private readonly publications;
+    set(accountId: string, observation: NativeQuotaObservation): this;
+    quota(lineage: string | undefined, accountUuid: string | undefined, committed: OAuthQuotaSnapshot | undefined, storage: AccountStorage, now?: number): {
+        quota: OAuthQuotaSnapshot;
+        clearAt?: number;
+    } | undefined;
+    publish(accountId: string, observation: NativeQuotaObservation, write: () => Promise<boolean>): Promise<void>;
+    drain(): Promise<void>;
+}

package/dist/native-transient-account.d.ts

@@ -31,8 +31,7 @@ export declare function isNativeTransientAccountError(value: unknown): value is
  * budget. Each wait between attempts ends early when any of `signals`
  * aborts; `check` is then called after the leases are released and is
  * expected to throw the caller's cancellation error. `check` runs before
- * every attempt too, so a cancelled caller never takes a lock. `now` must be
- * the clock the pool's writers stamp their lock expiry with, or a live
- * writer's lock could be judged expired and taken over.
+ * every attempt too, so a cancelled caller never takes a lock. All pool
+ * leases use wall time, independently of logical observation timestamps.
  */
-export declare function joinNativePoolWrite(paths: NativePoolStorePaths, signals: readonly AbortSignal[], check: () => void, now?: () => number): Promise<'joined' | 'deadline'>;
+export declare function joinNativePoolWrite(paths: NativePoolStorePaths, signals: readonly AbortSignal[], check: () => void): Promise<'joined' | 'deadline'>;

package/dist/native-ui.d.ts

@@ -21,6 +21,8 @@ export interface NativeUiOptions {
     readonly readMode: () => Promise<NativeMenuCustodyMode>;
     /** Token-free account names, credential IDs and states used to show which vault account needs re-login and its replacement command. */
     readonly readAccounts?: () => Promise<import('./native-account-view.ts').NativeAccountSnapshot>;
+    /** Re-read the separate host-login notice on each local Accounts render. */
+    readonly readSeparateHostLoginNotice?: () => Promise<boolean>;
     /**
      * Disconnects this host from the vault; while enrolled, this is the host's
      * only enrollment action. Before ending the enrollment, the callback

package/dist/native-usage-publication.d.ts

@@ -4,6 +4,11 @@
  * The error classes are not public runtime exports, so match name and code.
  */
 export declare function usagePublicationRefusalIsFatal(error: unknown): boolean;
+/** Return only allowlisted classes and codes, never the exception text. */
+export declare function classifySafeErrorForLog(error: unknown): {
+    name: string;
+    code: string;
+};
 /** Own advisory writes for one host instance and join them before runtime close. */
 export declare function createNativeUsagePublisher(channel: string): {
     observe: (write: Promise<unknown>) => Promise<void>;

package/dist/native-vault-runtime.d.ts

@@ -2,6 +2,7 @@ import { type ClaustrumClientOptions } from '@cortexkit/claustrum-client';
 import { type OAuthAccountProfile, type OAuthQuotaSnapshot, type PrimeUsageDelta } from './accounts.ts';
 import { type NativeAccountMetadataPatch } from './native-account-view.ts';
 import { type NativeCustodyClient, type NativeCustodyInventory, type NativeCustodyReceipt, type NativeCustodyReporterSource, type NativeCustodyRetry } from './native-custody.ts';
+import { NativeQuotaObservations } from './native-quota-observations.ts';
 import { type NativeRosterSeedInput, type NativeVaultRosterDocument, type NativeVaultRosterSeed } from './native-roster-seed.ts';
 import { type NativeRuntimeState } from './native-runtime.ts';
 import type { NativeVaultPaths } from './native-vault-paths.ts';
@@ -53,6 +54,9 @@ export interface NativeDisplayProfile {
 /** Build a NativeDisplayProfile from a validated profile and its publication. */
 export declare function nativeDisplayProfile(profile: OAuthAccountProfile, publish: () => Promise<boolean>, isCurrent: () => Promise<boolean>): NativeDisplayProfile;
 export interface NativeVaultRuntime {
+    readonly quotaObservations: NativeQuotaObservations;
+    drainQuotaPublications(): Promise<void>;
+    quotaLineage(routeId: string, credentialId: string | undefined, accountIdentity: string | undefined): string | undefined;
     /** Subscribe to one discovery loop; notifications contain no credential material. */
     watch(options: NativeVaultWatchOptions): NativeVaultWatch;
     initializeSettings(): Promise<void>;

package/dist/network-errors.d.ts

@@ -1 +1,2 @@
+export declare function transientNetworkErrorCode(error: unknown): string | undefined;
 export declare function isTransientNetworkError(error: unknown): boolean;

package/dist/pool-authority.d.ts

@@ -23,6 +23,7 @@ export interface NativeMigrationInput {
      * keeps native serving blocked until the separate vault activation commits.
      */
     activation?: 'requested';
+    nativeSettingsDigest?: string;
 }
 export interface NativeMigrationExpectations {
     expectedHostAuth: string;
@@ -97,8 +98,7 @@ export interface NativeCustodyActivationPlan {
 export type NativeCustodyActivation = {
     kind: 'requested';
 } | NativeCustodyActivationPlan;
-export interface NativeMigrationJournal {
-    version: 4;
+interface NativeMigrationRecord {
     storageId: string;
     host: 'opencode' | 'pi';
     phase: NativeMigrationPhase;
@@ -114,6 +114,22 @@ export interface NativeMigrationJournal {
      */
     activation: NativeCustodyActivation | null;
 }
+export type NativeLegacyMigrationJournal = NativeMigrationRecord & ({
+    version: 4;
+    kind?: never;
+} | {
+    version: 5;
+    kind: 'legacy-import';
+    nativeSettingsDigest: string;
+});
+export interface NativeEmptyInitJournal {
+    version: 5;
+    kind: 'empty-init';
+    storageId: string;
+    host: 'opencode';
+    phase: 'committed';
+}
+export type NativeMigrationJournal = NativeLegacyMigrationJournal | NativeEmptyInitJournal;
 export declare class NativeAuthorityError extends Error {
     readonly code: 'migration-required' | 'migration-incomplete' | 'invalid-journal' | 'journal-conflict';
     constructor(code: 'migration-required' | 'migration-incomplete' | 'invalid-journal' | 'journal-conflict');
@@ -126,7 +142,7 @@ export declare function readNativeMigrationJournal(paths: NativePoolPaths): Prom
  */
 export declare function nativeMigrationAuthorityPhase(journal: NativeMigrationJournal | undefined): 'committed' | 'retired' | undefined;
 /** An empty or readable store is not proof that the offline authority flip completed. */
-export declare function requireNativePoolAuthority(paths: NativePoolPaths): Promise<void>;
+export declare function requireNativePoolAuthority(paths: NativePoolPaths): Promise<NativeMigrationJournal>;
 interface JournalHooks {
     /** Outer controller and pool leases remain held through the atomic journal rename. */
     assertOwned?: () => Promise<void>;
@@ -137,23 +153,25 @@ interface JournalHooks {
     onWriteStep?: (step: 'before-write' | 'after-write', journal: NativeMigrationJournal) => Promise<void>;
 }
 /** Migration resume retains the original digests and resolved paths so a retry cannot adopt changed inputs or redirect writes. */
-export declare function beginNativeMigration(paths: NativePoolPaths, input: NativeMigrationInput, hooks?: JournalHooks): Promise<NativeMigrationJournal>;
+export declare function beginNativeMigration(paths: NativePoolPaths, input: NativeMigrationInput, hooks?: JournalHooks): Promise<NativeLegacyMigrationJournal>;
 /** Save the expected host-auth entry and routing digests together before changing files, so recovery can recognize completed writes. */
-export declare function recordNativeMigrationExpectations(paths: NativePoolPaths, expectations: NativeMigrationExpectations, hooks?: JournalHooks): Promise<NativeMigrationJournal>;
+export declare function recordNativeMigrationExpectations(paths: NativePoolPaths, expectations: NativeMigrationExpectations, hooks?: JournalHooks): Promise<NativeLegacyMigrationJournal>;
 /**
  * Advance one phase at a time. A retry of the same transition returns the journal.
  * Before recording activation, the caller must compare the host's Anthropic auth
  * entry and routing file with the saved expected values. This journal records the
  * migration stage; it does not read or verify those files.
  */
-export declare function advanceNativeMigration(paths: NativePoolPaths, expected: NativeMigrationPhase, next: NativeMigrationPhase, hooks?: JournalHooks): Promise<NativeMigrationJournal>;
+export declare function advanceNativeMigration(paths: NativePoolPaths, expected: NativeMigrationPhase, next: NativeMigrationPhase, hooks?: JournalHooks): Promise<NativeLegacyMigrationJournal>;
 /**
  * Record the prepared switch to vault custody on a retired migration. From
  * this write until the activation commits, the pool authorizes no serving.
  * Retrying with the identical plan returns the journal; any other plan is a
  * conflict, so a resumed setup can never replace what it recorded.
  */
-export declare function recordNativeCustodyActivation(paths: NativePoolPaths, plan: NativeCustodyActivationPlan, hooks?: JournalHooks): Promise<NativeMigrationJournal>;
+export declare function recordNativeCustodyActivation(paths: NativePoolPaths, plan: NativeCustodyActivationPlan, hooks?: JournalHooks): Promise<NativeLegacyMigrationJournal>;
 /** Advance a recorded activation one phase; never backwards or across a phase. */
-export declare function advanceNativeCustodyActivation(paths: NativePoolPaths, expected: NativeCustodyActivationPhase, next: NativeCustodyActivationPhase, hooks?: JournalHooks): Promise<NativeMigrationJournal>;
+export declare function advanceNativeCustodyActivation(paths: NativePoolPaths, expected: NativeCustodyActivationPhase, next: NativeCustodyActivationPhase, hooks?: JournalHooks): Promise<NativeLegacyMigrationJournal>;
+/** Publish local authority without inventing migration inputs or creating a pool. */
+export declare function beginNativeEmptyInit(paths: NativePoolPaths, hooks?: JournalHooks): Promise<NativeEmptyInitJournal>;
 export {};

package/dist/pool-paths.d.ts

@@ -8,6 +8,8 @@ export interface NativePoolPaths {
     roster: string;
     storageId: string;
 }
+/** Local hosts share the native pool's routing file unless explicitly overridden. */
+export declare function resolveLocalRoutingDestination(host: 'opencode' | 'pi', paths: NativePoolPaths, env: NodeJS.ProcessEnv): string;
 /**
  * Resolve existing parent aliases and nonexistent leaves without creating files.
  * This can follow a leaf symlink, so it does not establish configured-leaf safety.

package/dist/quotas.d.ts

@@ -1,5 +1,19 @@
-import type { AccountStorage, OAuthQuotaSnapshot, QuotaMoney } from './accounts.ts';
+import { formatQuota, type ProjectedQuota, quotaTextParts, quotaWindowParts } from "./internal-types/quota/index.js";
+import type { AccountQuotaWindow, AccountScopedQuotaWindow, AccountStorage, OAuthQuotaSnapshot } from './accounts.ts';
 export declare const CLAUDE_QUOTAS_COMMAND_NAME = "claude-quota";
+export type { QuotaWindowPart } from "./internal-types/quota/index.js";
+export { formatQuota, quotaTextParts, quotaWindowParts };
+type DisplayWindow = Omit<AccountQuotaWindow, 'checkedAt'> & {
+    checkedAt?: number;
+};
+/** Sidebar files written by older versions may not retain reading times. */
+export type QuotaDisplaySnapshot = Pick<OAuthQuotaSnapshot, 'checkedAt' | 'extraUsage' | 'bindingWindow'> & {
+    five_hour?: DisplayWindow;
+    seven_day?: DisplayWindow;
+    scoped?: (Omit<AccountScopedQuotaWindow, 'checkedAt'> & DisplayWindow)[];
+};
+/** Adapt every reported window without projecting away other model families. */
+export declare function quotaDisplayProjection(snapshot: QuotaDisplaySnapshot | null | undefined, now: number): ProjectedQuota | undefined;
 export type QuotaAccountSummary = {
     name: string;
     role: 'main' | 'fallback';
@@ -9,7 +23,6 @@ export type QuotaAccountSummary = {
     error?: string;
     tierLabel?: string;
 };
-export declare function formatQuotaMoney(money: QuotaMoney): string;
 export declare function buildFallbackQuotaSummaries(storage: AccountStorage | null, errors?: ReadonlyMap<string, string>): {
     name: string;
     role: 'fallback';

package/dist/relay.d.ts

@@ -6,6 +6,26 @@ export type RelayConfig = {
     fallbackToDirect: boolean;
     transport: 'http' | 'websocket';
 };
+/**
+ * The transport a stored relay configuration selects. A stored `http` or
+ * `websocket` value always wins. Without one (missing or unrecognized), the
+ * URL decides: a `ws://` or `wss://` URL selects WebSocket, so hand-edited
+ * WebSocket configurations keep working; any other URL selects HTTP, the
+ * documented default. Request dispatch and the relay status shown to users
+ * both call this, so they cannot report different transports.
+ */
+export declare function effectiveRelayTransport(stored: unknown, url: unknown): RelayConfig['transport'];
+/**
+ * Secret-free relay status for displays such as the OpenCode sidebar: the
+ * transport requests will use, or null when requests cannot use the relay
+ * because it is disabled, has no URL or has no token. Native account
+ * snapshots never carry the private token; they set `tokenConfigured` to say
+ * whether one is stored.
+ */
+export declare function effectiveRelayStatus(relay: AccountStorage['relay'] | undefined): {
+    enabled: true;
+    transport: RelayConfig['transport'];
+} | null;
 export type RelayPatch = {
     start: number;
     deleteCount: number;

package/dist/sticky-routing.d.ts

@@ -106,12 +106,15 @@ export declare class StickySessionRouter {
         now?: () => number;
         assignmentTtlMs?: number;
         vaultSeed?: NativeVaultRoutingSeed;
+        localRecoveryPath?: string;
     });
     private now;
     private readState;
     private readStateMtimeNs;
     private refreshStateIfChanged;
     private acquireLock;
+    private recoverLocalPins;
+    private fillLocalPins;
     private assignmentIsActive;
     private prune;
     private writeState;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/anthropic-auth-core",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "type": "module",
   "repository": {
     "type": "git",
@@ -30,11 +30,12 @@
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@cortexkit/common-auth": "0.15.0"
+    "@cortexkit/common-auth": "0.18.0"
   },
   "dependencies": {
     "@cortexkit/claustrum-client": "0.9.0",
     "@cortexkit/private-files": "0.2.1",
+    "@cortexkit/subc-client": "^0.16.0",
     "jsonc-parser": "^3.3.1",
     "xxhash-wasm": "^1.1.0"
   }