@cortexkit/anthropic-auth-core 2.2.4 → 2.2.5

package/dist/index.js

@@ -2730,7 +2730,7 @@ async function assertHostsStopped(fence, env) {
 
 // ../../node_modules/@cortexkit/common-auth/dist/setup/enroll.js
 var ENROLLMENT_INCOMPLETE_MESSAGE = "Claustrum enrollment did not complete. Inspect and approve with ck, then rerun setup.";
-var UNSUPPORTED_VAULT_MESSAGE = "This Claustrum vault does not support connecting plugins yet, so setup cannot connect to it. Run setup without --claustrum to use local accounts.";
+var UNSUPPORTED_VAULT_MESSAGE = 'This Claustrum vault is too old to connect plugins. Run ck upgrade to move to Claustrum v0.2.0 or newer (read "Upgrading from v0.1.3" in its release notes first), or run setup without --claustrum to use local accounts.';
 var ENROLLMENT_WAIT_MS = 300000;
 var APPROVAL_POLL_MS = 1000;
 var PROPOSE_BACKOFF_MS = [1000, 2000, 4000, 8000, 16000, 30000];
@@ -18408,6 +18408,52 @@ function acceptVaultRoute(path2, routeId) {
     };
   });
 }
+function invalidOrder(message) {
+  return new ClaustrumConsumerError("invalid-order", message);
+}
+function vaultOrderProblem(rows, routeIds) {
+  if (!Array.isArray(routeIds))
+    return "route ids must be an array of route ids";
+  const rosterIds = new Set(rows.map((row) => row.routeId));
+  const given = new Set;
+  for (const id2 of routeIds) {
+    if (typeof id2 !== "string")
+      return "route ids must be an array of route ids";
+    if (given.has(id2))
+      return `route id ${id2} appears more than once`;
+    if (!rosterIds.has(id2))
+      return `route id ${id2} is not in the roster`;
+    given.add(id2);
+  }
+  const missing2 = [...rosterIds].filter((id2) => !given.has(id2)).length;
+  if (missing2 > 0)
+    return `the order leaves out ${missing2} roster route id${missing2 === 1 ? "" : "s"}`;
+  return;
+}
+function reorderVaultRoster(path2, routeIds, options = {}) {
+  return mutateVaultRoster(path2, (current) => {
+    const rows = current?.rows ?? [];
+    const problem = vaultOrderProblem(rows, routeIds);
+    if (problem)
+      throw invalidOrder(problem);
+    const byId = new Map;
+    for (const row of rows) {
+      const group = byId.get(row.routeId);
+      if (group)
+        group.push(row);
+      else
+        byId.set(row.routeId, [row]);
+    }
+    const ids = [...routeIds];
+    const next = ids.flatMap((id2) => byId.get(id2) ?? []);
+    if (!current || next.every((row, index) => row === rows[index]))
+      return { result: { ids, outcome: "unchanged" } };
+    return {
+      next: { ...current, rows: next },
+      result: { ids, outcome: "reordered" }
+    };
+  }, { ...options.signal && { signal: options.signal } });
+}
 function receiptFence(row, receipt) {
   if (!memberIds(row).includes(receipt.credentialId))
     return "refuse";
@@ -19087,7 +19133,11 @@ class ClaustrumConsumer {
       let current;
       try {
         current = await this.authorize(routeId, signal);
-      } catch {}
+        signal?.throwIfAborted();
+      } catch (error) {
+        if (signal?.aborted)
+          throw error;
+      }
       if (decideScopedRetryAfter401(options.site, served, current, this.#logger)) {
         await response.body?.cancel().catch(() => {});
         served = current;
@@ -19114,6 +19164,12 @@ class ClaustrumConsumer {
     await acceptVaultRoute(this.#options.rosterPath, routeId);
     this.#roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
   }
+  async reorder(routeIds) {
+    this.#assertOpen();
+    const result = await reorderVaultRoster(this.#options.rosterPath, routeIds);
+    this.#roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
+    return result;
+  }
   async recordQuota(routeId, observation, attempt) {
     this.#assertOpen();
     return recordVaultQuota(this.#options.rosterPath, {
@@ -19187,6 +19243,7 @@ function nativeCode(value) {
     case "host-slot-login":
     case "host-slot-placeholder":
     case "placeholder-refresh":
+    case "invalid-order":
       return value;
     default:
       return "unavailable";
@@ -21364,6 +21421,7 @@ var codes = new Set([
   "host-slot-login",
   "host-slot-placeholder",
   "placeholder-refresh",
+  "invalid-order",
   "publication-refused",
   "unsafe-runtime",
   "invalid-runtime",
@@ -24505,7 +24563,7 @@ class StickySessionRouter {
     }) > 0) : undefined;
     const selected = preferred ?? this.selectCandidate({ ...input, candidates, state });
     if (!selected) {
-      if (current) {
+      if (current && !input.preserveOnNoCandidate) {
         delete state.assignments[key];
         save("delete");
       }

package/dist/internal-types/claustrum/consumer.d.ts

@@ -4,7 +4,7 @@ import type { RoutingRow } from '../routing/index.js';
 import { type ClaustrumFamily, type ClaustrumScopedAttempt, type ClaustrumScopedClient, type IdentityParser, type KeptReceiptState, type VaultGrantReach } from './custody.js';
 import { type ClaustrumLogger } from './errors.js';
 import { type InsulaQuotaOptions, type InsulaQuotaResult } from './insula.js';
-import { type AccountMapper, type QuotaReceipt, type VaultRosterFile } from './roster.js';
+import { type AccountMapper, type QuotaReceipt, type ReorderVaultRosterResult, type VaultRosterFile } from './roster.js';
 import { type WatchMode } from './watch.js';
 export interface ClaustrumConsumerOptions<Q = QuotaObservation> {
     /**
@@ -157,6 +157,12 @@ export declare class ClaustrumConsumer<Q = QuotaObservation> {
     /** Decline a vault account: it stays listed and never routes until accepted. */
     decline(routeId: string): Promise<void>;
     accept(routeId: string): Promise<void>;
+    /**
+     * Set the order vault accounts are tried in (`reorderVaultRoster`), then
+     * re-read the roster, so the next routing decision in this process uses
+     * the new order without waiting for a discovery. Never contacts the vault.
+     */
+    reorder(routeIds: readonly string[]): Promise<ReorderVaultRosterResult>;
     /**
      * Store a quota or profile observation for a vault route. The receipt the
      * reading was taken with is required: the observation lands only while the

package/dist/internal-types/claustrum/errors.d.ts

@@ -4,7 +4,7 @@
  * `code`, a `class` and an `action`), so callers can tell the vault's verdict
  * apart from a check made on this side.
  */
-export type ClaustrumConsumerFailureKind = 'closed' | 'not-enrolled' | 'invalid-token' | 'unavailable' | 'identity-changed' | 'identity-unasserted' | 'insufficient-validity' | 'invalid-material' | 'not-active' | 'route-unavailable' | 'route-declined' | 'no-receipt' | 'unsafe-file' | 'invalid-state' | 'wrong-consumer' | 'roster-busy' | 'host-slot-login' | 'host-slot-placeholder' | 'placeholder-refresh';
+export type ClaustrumConsumerFailureKind = 'closed' | 'not-enrolled' | 'invalid-token' | 'unavailable' | 'identity-changed' | 'identity-unasserted' | 'insufficient-validity' | 'invalid-material' | 'not-active' | 'route-unavailable' | 'route-declined' | 'no-receipt' | 'unsafe-file' | 'invalid-state' | 'wrong-consumer' | 'roster-busy' | 'host-slot-login' | 'host-slot-placeholder' | 'placeholder-refresh' | 'invalid-order';
 export declare class ClaustrumConsumerError extends Error {
     readonly kind: ClaustrumConsumerFailureKind;
     constructor(kind: ClaustrumConsumerFailureKind, message: string);

package/dist/internal-types/claustrum/index.d.ts

@@ -10,7 +10,7 @@ export { assertHostSlotMatchesMode, assertNotCustodyPlaceholder, CUSTODY_PLACEHO
 export { acquireInsulaQuotaSource, type InsulaQuotaContext, type InsulaQuotaLookup, type InsulaQuotaMiss, type InsulaQuotaOptions, type InsulaQuotaReading, type InsulaQuotaResult, type InsulaQuotaSource, type InsulaUsageEntry, type InsulaUsageTransport, type InsulaUsageWatch, type InsulaUsageWindow, type InsulaWatchOptions, } from './insula.js';
 export { acceptAccount, type DeclinedAccount, declineAccount, isDeclined, } from './interlock.js';
 export { drainVaultQuota } from './quota-writer.js';
-export { type AccountMapper, acceptVaultRoute, DEFAULT_ROUTE_PREFIX, declineVaultRoute, type MutateVaultRosterOptions, mutateVaultRoster, type ProjectionOptions, projectVaultRoster, type QuotaReceipt, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, resolveVaultPrimary, type VaultPrimary, type VaultPrimaryBinding, type VaultPrimaryUnavailableReason, type VaultRosterFile, type VaultRosterLockContext, type VaultRosterRow, vaultRoutingRows, } from './roster.js';
+export { type AccountMapper, acceptVaultRoute, DEFAULT_ROUTE_PREFIX, declineVaultRoute, type MutateVaultRosterOptions, mutateVaultRoster, type ProjectionOptions, projectVaultRoster, type QuotaReceipt, type ReorderVaultRosterOptions, type ReorderVaultRosterResult, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, reorderVaultRoster, resolveVaultPrimary, type VaultPrimary, type VaultPrimaryBinding, type VaultPrimaryUnavailableReason, type VaultRosterFile, type VaultRosterLockContext, type VaultRosterRow, vaultRoutingRows, } from './roster.js';
 export { type ChangeNotice, ChangeNoticeReader, RESUBSCRIBE_BACKOFF_MS, SAFETY_POLL_MS, ScopedRosterWatch, type ScopedRosterWatchOptions, type ScopedWatchEnd, type ScopedWatchHandle, type ScopedWatchNoticeShape, type ScopedWatchSource, WATCH_RETRY_MS, type WatchMode, } from './watch.js';
 /**
  * Connect the client that lists and fetches this consumer's vault credentials

package/dist/internal-types/claustrum/roster.d.ts

@@ -119,6 +119,37 @@ export declare function mutateVaultRoster<T>(path: string, change: (current: Vau
 export declare function declineVaultRoute(path: string, routeId: string): Promise<undefined>;
 /** Lift the user's decline for a vault account and every alias of it. */
 export declare function acceptVaultRoute(path: string, routeId: string): Promise<undefined>;
+/** Options of `reorderVaultRoster`. */
+export interface ReorderVaultRosterOptions {
+    /** Aborts the wait for the roster's write lock. */
+    signal?: AbortSignal;
+}
+export interface ReorderVaultRosterResult {
+    /** The route id order now on disk. */
+    ids: string[];
+    /** `unchanged` when the roster was already in this order; nothing was written. */
+    outcome: 'reordered' | 'unchanged';
+}
+/**
+ * Set the order vault accounts are tried in. Routing reads that order from
+ * the roster's row order (`vaultRoutingRows`), and a later discovery keeps
+ * each account at its position, so the order lasts until the next reorder.
+ * The order is this host's routing preference: the vault has no order of its
+ * own, and this never contacts it.
+ *
+ * `routeIds` must name every roster route id exactly once; anything else
+ * (an unknown, missing or repeated id) refuses with `invalid-order` and
+ * writes nothing. It runs under the roster's write lock, like every other
+ * roster write, so a quota reading or decline committed meanwhile is kept.
+ * Each row is kept as the same object, so only the positions change: every
+ * row's fields and the rest of the file stay as they were. An order equal to
+ * the current one writes nothing. A host with no roster file yet has no
+ * routes, so only the empty order is accepted.
+ *
+ * A `ClaustrumConsumer` in the same process does not see the new order until
+ * it re-reads the file: call `consumer.reorder` instead to update both.
+ */
+export declare function reorderVaultRoster(path: string, routeIds: readonly string[], options?: ReorderVaultRosterOptions): Promise<ReorderVaultRosterResult>;
 /**
  * The receipt fields a quota or profile observation must carry to say which
  * send (credential and account) it came from. Pass the

package/dist/internal-types/commands/builtins.d.ts

@@ -48,6 +48,43 @@ export interface RoutingSectionOptions {
      */
     orderedVariants?: MenuChoice[];
     formerMainId?: string;
+    /**
+     * The vault accounts' routing order, for a plugin that can run in vault
+     * mode. Called on each build; return the order while the plugin routes
+     * through vault accounts and undefined otherwise. While it returns one, the
+     * section shows and sets the vault accounts' order (by the name the menu
+     * shows for each account) instead of the pool roster's. Wire it to
+     * `ClaustrumConsumer.snapshot()` and `ClaustrumConsumer.reorder`, or to
+     * `readVaultRoster` and `reorderVaultRoster` for a plugin without a
+     * consumer.
+     */
+    vaultOrder?: () => VaultRoutingOrder | undefined | Promise<VaultRoutingOrder | undefined>;
+}
+/**
+ * The order vault accounts are tried in, as the Routing section reads and
+ * sets it in vault mode. Shaped after `/claustrum`'s roster, without
+ * importing it, so the menu does not need the vault client.
+ */
+export interface VaultRoutingOrder {
+    /**
+     * Every vault roster row, in roster (routing) order: its route id and the
+     * name the plugin shows for that account (the roster row's `label`, or its
+     * email). Route ids are long and opaque, so the section shows and accepts
+     * labels; a route id is still accepted wherever a label is.
+     */
+    rows: readonly {
+        id: string;
+        label: string;
+    }[];
+    /**
+     * Sets the order. `ids` are route ids, every one exactly once. Wire it to
+     * `ClaustrumConsumer.reorder` or `reorderVaultRoster`, which refuse any
+     * other list without writing.
+     */
+    reorder(ids: readonly string[]): Promise<{
+        ids: readonly string[];
+        outcome: 'reordered' | 'unchanged';
+    }>;
 }
 export interface LimitsSectionOptions {
     /**

package/dist/internal-types/commands/index.d.ts

@@ -1,4 +1,4 @@
-export type { AccountsSectionOptions, LimitsSectionOptions, LoginOutcome, QuotaSectionOptions, RoutingSectionOptions, } from './builtins.js';
+export type { AccountsSectionOptions, LimitsSectionOptions, LoginOutcome, QuotaSectionOptions, RoutingSectionOptions, VaultRoutingOrder, } from './builtins.js';
 export { MENU_DISABLED_REASON } from './builtins.js';
 export type { CommandMenu, CommandMenuOptions, StoreSectionSlot, } from './menu.js';
 export { createCommandMenu, parseApplyRequest } from './menu.js';

package/dist/internal-types/setup/enroll.d.ts

@@ -1,7 +1,7 @@
 import { type MenuTerminal } from '../auth-menu/terminal.js';
 import type { SetupHost, SetupIO, SetupPlugin } from './types.js';
 /** Fixed text: no version, host or account detail, so it is safe to print anywhere. */
-export declare const UNSUPPORTED_VAULT_MESSAGE = "This Claustrum vault does not support connecting plugins yet, so setup cannot connect to it. Run setup without --claustrum to use local accounts.";
+export declare const UNSUPPORTED_VAULT_MESSAGE = "This Claustrum vault is too old to connect plugins. Run ck upgrade to move to Claustrum v0.2.0 or newer (read \"Upgrading from v0.1.3\" in its release notes first), or run setup without --claustrum to use local accounts.";
 /**
  * The longest setup waits, in total, for the vault to create the enrollment
  * request and for an operator to approve it. It matches the wait setup always

package/dist/native-custody.d.ts

@@ -203,7 +203,7 @@ export interface NativeCustodyInventory {
         }[];
     };
 }
-export type NativeCustodyErrorCode = 'closed' | 'not-enrolled' | 'invalid-token' | 'unavailable' | 'identity-changed' | 'identity-unasserted' | 'insufficient-validity' | 'invalid-material' | 'not-active' | 'route-unavailable' | 'route-declined' | 'no-receipt' | 'unsafe-file' | 'invalid-state' | 'wrong-consumer' | 'roster-busy' | 'host-slot-login' | 'host-slot-placeholder' | 'placeholder-refresh';
+export type NativeCustodyErrorCode = 'closed' | 'not-enrolled' | 'invalid-token' | 'unavailable' | 'identity-changed' | 'identity-unasserted' | 'insufficient-validity' | 'invalid-material' | 'not-active' | 'route-unavailable' | 'route-declined' | 'no-receipt' | 'unsafe-file' | 'invalid-state' | 'wrong-consumer' | 'roster-busy' | 'host-slot-login' | 'host-slot-placeholder' | 'placeholder-refresh' | 'invalid-order';
 export declare class NativeCustodyError extends Error {
     readonly code: NativeCustodyErrorCode;
     constructor(code: NativeCustodyErrorCode);

package/dist/sticky-routing.d.ts

@@ -148,6 +148,8 @@ export declare class StickySessionRouter {
         inputBytes: number;
         preferredAccountId?: string;
         excludeAccountIds?: ReadonlySet<string>;
+        /** Leave the current pin intact when selection cannot offer an account. */
+        preserveOnNoCandidate?: boolean;
     }): Promise<StickyRouteResolution | null>;
     clear(sessionId: string): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/anthropic-auth-core",
-  "version": "2.2.4",
+  "version": "2.2.5",
   "type": "module",
   "repository": {
     "type": "git",
@@ -30,7 +30,7 @@
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@cortexkit/common-auth": "0.24.0"
+    "@cortexkit/common-auth": "0.25.0"
   },
   "dependencies": {
     "@cortexkit/claustrum-client": "0.12.0",