@cortexkit/common-auth 0.2.3 → 0.2.4

package/dist/auth-menu/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auth-menu/index.js

@@ -0,0 +1,2 @@
+// Placeholder so the export resolves until this subpath is built.
+export {};

package/dist/cachekeep/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cachekeep/index.js

@@ -0,0 +1,2 @@
+// Placeholder so the export resolves until this subpath is built.
+export {};

package/dist/claustrum/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/claustrum/index.js

@@ -0,0 +1,2 @@
+// Placeholder so the export resolves until this subpath is built.
+export {};

package/dist/commands/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/index.js

@@ -0,0 +1,2 @@
+// Placeholder so the export resolves until this subpath is built.
+export {};

package/dist/dump/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dump/index.js

@@ -0,0 +1,2 @@
+// Placeholder so the export resolves until this subpath is built.
+export {};

package/dist/opencode2/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/opencode2/index.js

@@ -0,0 +1,2 @@
+// Placeholder so the export resolves until this subpath is built.
+export {};

package/dist/store/errors.d.ts

@@ -1,6 +1,6 @@
 import type { StoredCredential } from './schema.js';
 /** Every library operation that can fail, as named in the failure value. */
-export type PoolOperation = 'initialize' | 'add' | 'replace' | 'rotate' | 'disable' | 'enable' | 'remove' | 'recordIdentity' | 'refresh' | 'pull';
+export type PoolOperation = 'initialize' | 'add' | 'replace' | 'rotate' | 'disable' | 'enable' | 'remove' | 'reorder' | 'recordIdentity' | 'refresh' | 'pull';
 /**
  * How far an operation got before it failed.
  *
@@ -16,7 +16,7 @@ export type PoolFailurePhase = 'before-first-write' | 'after-first-write' | 'pul
  * lock outcomes (a wait that ran out, and a lease found lost); the rest are
  * refusals and failures of the operation itself.
  */
-export type PoolFailureKind = 'lock-contention' | 'lock-ownership' | 'pending-migration' | 'load-error' | 'unknown-row' | 'invalid-row' | 'invalid-input' | 'id-exists' | 'id-removed' | 'type-mismatch' | 'no-credential' | 'row-disabled' | 'row-protected' | 'duplicate-identity' | 'row-key-changed' | 'refresh-stamp-ahead' | 'attribution' | 'provider' | 'pull' | 'invalid-quota' | 'after-persist-hook' | 'unexpected';
+export type PoolFailureKind = 'lock-contention' | 'lock-ownership' | 'pending-migration' | 'load-error' | 'unknown-row' | 'invalid-row' | 'invalid-input' | 'id-exists' | 'id-removed' | 'type-mismatch' | 'no-credential' | 'row-disabled' | 'row-protected' | 'duplicate-identity' | 'row-key-changed' | 'invalid-order' | 'refresh-stamp-ahead' | 'attribution' | 'provider' | 'pull' | 'invalid-quota' | 'after-persist-hook' | 'unexpected';
 /**
  * The single failure value of every store operation. `committed` is present
  * only when the operation had already written a credential to the state file

package/dist/store/hooks.d.ts

@@ -9,4 +9,4 @@ export interface PoolLogger {
  * Runs a failure hook. A hook that throws never replaces the failure it was
  * handed: its exception is logged and discarded.
  */
-export declare function callFailureHook<E>(operation: PoolOperation, hook: ((rowId: string, error: E) => void | Promise<void>) | undefined, rowId: string, error: E, logger: PoolLogger | undefined): Promise<void>;
+export declare function callFailureHook<E, R extends string | undefined>(operation: PoolOperation, hook: ((rowId: R, error: E) => void | Promise<void>) | undefined, rowId: R, error: E, logger: PoolLogger | undefined): Promise<void>;

package/dist/store/index.d.ts

@@ -10,7 +10,7 @@ export type { PullHook, PullRequest } from './pull.js';
 export type { ProviderRefresh, ProviderRefreshResult, RefreshOptions, RefreshOutcome, } from './refresh.js';
 export type { LockEvent, PoolLockOptions, PoolLockSpec, } from './refresh-lock.js';
 export { POOL_LOCK_DEFAULTS } from './refresh-lock.js';
-export type { AddInput, AddResult, FailureHook, RemoveOptions, RemoveResult, RemoveView, RowOperationOptions, RowToggleOptions, } from './rows.js';
+export type { AddInput, AddResult, FailureHook, RemoveOptions, RemoveResult, RemoveView, ReorderOptions, ReorderResult, RowOperationOptions, RowToggleOptions, } from './rows.js';
 export type { PullReason } from './runtime.js';
 export type { ApiKeyCredential, OAuthCredential, PoolCredential, PoolRow, QuotaCodec, StoredCredential, } from './schema.js';
 export { fingerprintOf, LEGACY_STORE_VERSION, POOL_KEY, POOL_ROWS_KEY, POOL_SCHEMA_VERSION, REFRESH_STAMP_TOLERANCE_MS, rowLockKey, } from './schema.js';

package/dist/store/mutate.d.ts

@@ -127,6 +127,7 @@ export declare function toFailure(error: unknown, operation: PoolOperation, rowI
  * The frame every lock-holding operation runs in: failures are mapped onto
  * the failure value, handed to the failure hook while the outer locks are
  * still held (the store locks are already released), and rethrown; every
- * lock is released afterwards.
+ * lock is released afterwards. `rowId` is undefined for an operation that
+ * names no row (`reorder`).
  */
-export declare function runOperation<T>(ctx: StoreContext, operation: PoolOperation, rowId: string, onFailure: ((rowId: string, error: PoolOperationError) => void | Promise<void>) | undefined, body: (locks: LockStack, progress: Progress) => Promise<T>): Promise<T>;
+export declare function runOperation<T, R extends string | undefined = string>(ctx: StoreContext, operation: PoolOperation, rowId: R, onFailure: ((rowId: R, error: PoolOperationError) => void | Promise<void>) | undefined, body: (locks: LockStack, progress: Progress) => Promise<T>): Promise<T>;

package/dist/store/mutate.js

@@ -335,7 +335,8 @@ export function toFailure(error, operation, rowId, progress) {
  * The frame every lock-holding operation runs in: failures are mapped onto
  * the failure value, handed to the failure hook while the outer locks are
  * still held (the store locks are already released), and rethrown; every
- * lock is released afterwards.
+ * lock is released afterwards. `rowId` is undefined for an operation that
+ * names no row (`reorder`).
  */
 export async function runOperation(ctx, operation, rowId, onFailure, body) {
     const locks = new LockStack(ctx.lockDefaults, ctx.lockEnv);

package/dist/store/pool.d.ts

@@ -5,7 +5,7 @@ import { type HoldPoint, type InitializeOutcome, type StoreContext } from './mut
 import { type PullHook } from './pull.js';
 import { type ProviderRefresh, type RefreshOptions, type RefreshOutcome } from './refresh.js';
 import { type LockEnvironment, type PoolLockOptions, type PoolLockSpec } from './refresh-lock.js';
-import { type AddInput, type AddResult, type RemoveOptions, type RemoveResult, type RowOperationOptions, type RowToggleOptions } from './rows.js';
+import { type AddInput, type AddResult, type RemoveOptions, type RemoveResult, type ReorderOptions, type ReorderResult, type RowOperationOptions, type RowToggleOptions } from './rows.js';
 import { type PoolCredential, type PoolRow, type QuotaCodec, type StoredCredential } from './schema.js';
 export interface OpenPoolStoreOptions {
     /** The provider every row of this pool belongs to; keys the provider-wide lock. */
@@ -101,6 +101,13 @@ export interface PoolStore {
      * (since 0.2.3). Locks as `disable`; `protect` can refuse the id.
      */
     remove(id: string, options?: RemoveOptions): Promise<RemoveResult>;
+    /**
+     * Sets the roster order (since 0.2.4) in one config write. `ids` must name
+     * every roster id exactly once; anything else refuses with `invalid-order`
+     * and writes nothing. Takes `extraLocks`, then the store locks; no row or
+     * provider-wide lock. Roster rows and their entries are left unchanged.
+     */
+    reorder(ids: readonly string[], options?: ReorderOptions): Promise<ReorderResult>;
     recordIdentity(id: string, identity: string, options?: RowOperationOptions): Promise<{
         id: string;
         disabled: string[];

package/dist/store/pool.js

@@ -3,7 +3,7 @@ import { initializePool, readPool, } from './mutate.js';
 import { PullScheduler } from './pull.js';
 import { refreshRow, } from './refresh.js';
 import { POOL_LOCK_DEFAULTS, } from './refresh-lock.js';
-import { addRow, disableRow, enableRow, recordRowIdentity, removeRow, replaceRow, rotateRow, } from './rows.js';
+import { addRow, disableRow, enableRow, recordRowIdentity, removeRow, reorderRows, replaceRow, rotateRow, } from './rows.js';
 import { POOL_SCHEMA_VERSION, } from './schema.js';
 /**
  * Process-wide memory per config file: ids whose per-row entry a library
@@ -94,6 +94,7 @@ export function openPoolStore(options) {
         disable: (id, reason, callOptions) => disableRow(rt, id, reason, callOptions),
         enable: (id, callOptions) => enableRow(rt, id, callOptions),
         remove: (id, callOptions) => removeRow(rt, id, callOptions),
+        reorder: (ids, callOptions) => reorderRows(rt, ids, callOptions),
         recordIdentity: (id, identity, callOptions) => recordRowIdentity(rt, id, identity, callOptions),
         refresh: (id, provider, callOptions) => refreshRow(rt, id, provider, callOptions),
         recordQuota: (id, attribution, observation) => recordQuota(rt, id, attribution, observation),

package/dist/store/rows.d.ts

@@ -1,4 +1,4 @@
-import type { PoolOperationError } from './errors.js';
+import { PoolOperationError } from './errors.js';
 import { type Transaction } from './mutate.js';
 import type { PoolLockSpec } from './refresh-lock.js';
 import { type StoreRuntime } from './runtime.js';
@@ -57,6 +57,23 @@ export type RemoveResult = {
      */
     outcome: 'removed' | 'completed';
 };
+/**
+ * Options of `reorder`. It names no row, so its failure hook is handed only
+ * the failure; it takes no row lock and no provider-wide lock, so the extra
+ * locks are taken first, then the store locks.
+ */
+export interface ReorderOptions {
+    /** Called once, awaited, on every non-success path, before the extra locks release. */
+    onFailure?: (error: PoolOperationError) => void | Promise<void>;
+    /** Locks taken, in this order, before the store locks. */
+    extraLocks?: readonly PoolLockSpec[];
+}
+export type ReorderResult = {
+    /** The roster order now on disk. */
+    ids: string[];
+    /** `unchanged` when the roster was already in this order; nothing was written. */
+    outcome: 'reordered' | 'unchanged';
+};
 export interface AddInput {
     id: string;
     credential: PoolCredential;
@@ -119,6 +136,16 @@ export declare function enableRow(rt: StoreRuntime, id: string, options?: RowTog
  * not reused by `add` in this process.
  */
 export declare function removeRow(rt: StoreRuntime, id: string, options?: RemoveOptions): Promise<RemoveResult>;
+/**
+ * Sets the roster order in one config write. `ids` must name every roster id
+ * exactly once; anything else refuses (`invalid-order`) before writing. The
+ * roster rows, the per-row entries and the state file are left as they are:
+ * only the order of the legacy `accounts` array changes, which older readers
+ * load as is. It takes the extra locks, then the store locks, and no row or
+ * provider-wide lock, since no row's credential, identity or quota changes.
+ * An order equal to the current one writes nothing.
+ */
+export declare function reorderRows(rt: StoreRuntime, ids: readonly string[], options?: ReorderOptions): Promise<ReorderResult>;
 export declare function recordRowIdentity(rt: StoreRuntime, id: string, identity: string, options?: RowOperationOptions): Promise<{
     id: string;
     disabled: string[];

package/dist/store/rows.js

@@ -1,3 +1,4 @@
+import { PoolOperationError } from './errors.js';
 import { assertNotInsideHook, runInsideHook } from './hooks.js';
 import { DUPLICATE_IDENTITY_REASON, disableIdentityDuplicates, disableIn, recordIdentityIn, } from './identity.js';
 import { notReadyError, readPool, runOperation, withTransaction, } from './mutate.js';
@@ -355,6 +356,98 @@ function hasStateAccount(state, id) {
     const accounts = state.accounts;
     return isRecord(accounts) && Object.hasOwn(accounts, id);
 }
+/** The id a roster row carries, or undefined for a row that names none. */
+function rosterIdOf(raw) {
+    return isRecord(raw) && typeof raw.id === 'string' ? raw.id : undefined;
+}
+/**
+ * Why `ids` is not an order of this roster: it must name every distinct
+ * roster id exactly once and nothing else.
+ */
+function orderProblem(roster, ids) {
+    if (!Array.isArray(ids))
+        return 'ids must be an array of roster ids';
+    const rosterIds = new Set();
+    for (const raw of roster) {
+        const id = rosterIdOf(raw);
+        if (id !== undefined)
+            rosterIds.add(id);
+    }
+    const given = new Set();
+    for (const id of ids) {
+        if (typeof id !== 'string')
+            return 'ids must be an array of roster ids';
+        if (given.has(id))
+            return `id ${id} appears more than once`;
+        if (!rosterIds.has(id))
+            return `id ${id} is not in the roster`;
+        given.add(id);
+    }
+    const missing = [...rosterIds].filter((id) => !given.has(id));
+    if (missing.length > 0)
+        return `the order leaves out roster id(s) ${missing.join(', ')}`;
+    return undefined;
+}
+/**
+ * The roster in the new order. Every roster row is kept as the same object,
+ * so its serialized bytes are unchanged. Rows that carry an id fill the
+ * positions such rows held before, in the order of `ids`; a second row with
+ * an already-seen id (invalid, but preserved) travels right after the first.
+ * A row that names no id cannot be ordered by id, so it keeps its position.
+ */
+function reorderedRoster(roster, ids) {
+    const byId = new Map();
+    for (const raw of roster) {
+        const id = rosterIdOf(raw);
+        if (id === undefined)
+            continue;
+        const group = byId.get(id);
+        if (group)
+            group.push(raw);
+        else
+            byId.set(id, [raw]);
+    }
+    const sequence = ids.flatMap((id) => byId.get(id) ?? []);
+    let next = 0;
+    return roster.map((raw) => rosterIdOf(raw) === undefined ? raw : sequence[next++]);
+}
+/**
+ * Sets the roster order in one config write. `ids` must name every roster id
+ * exactly once; anything else refuses (`invalid-order`) before writing. The
+ * roster rows, the per-row entries and the state file are left as they are:
+ * only the order of the legacy `accounts` array changes, which older readers
+ * load as is. It takes the extra locks, then the store locks, and no row or
+ * provider-wide lock, since no row's credential, identity or quota changes.
+ * An order equal to the current one writes nothing.
+ */
+export async function reorderRows(rt, ids, options = {}) {
+    assertNotInsideHook('reorder');
+    const { ctx } = rt;
+    const onFailure = options.onFailure;
+    return runOperation(ctx, 'reorder', undefined, onFailure && ((_rowId, error) => onFailure(error)), async (locks, progress) => {
+        for (const extra of options.extraLocks ?? [])
+            await locks.acquire(extra);
+        return withTransaction(ctx, locks, progress, { operation: 'reorder', rowId: undefined }, async (tx) => {
+            const roster = tx.roster();
+            const problem = orderProblem(roster, ids);
+            if (problem)
+                throw new PoolOperationError({
+                    operation: 'reorder',
+                    phase: 'before-first-write',
+                    retryable: false,
+                    kind: 'invalid-order',
+                    message: problem,
+                });
+            const order = [...ids];
+            const next = reorderedRoster(roster, order);
+            if (next.every((raw, index) => raw === roster[index]))
+                return { ids: order, outcome: 'unchanged' };
+            tx.config.accounts = next;
+            await tx.commitConfig();
+            return { ids: order, outcome: 'reordered' };
+        });
+    });
+}
 export async function recordRowIdentity(rt, id, identity, options = {}) {
     assertNotInsideHook('recordIdentity');
     return runOperation(rt.ctx, 'recordIdentity', id, options.onFailure, async (locks, progress) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cortexkit/common-auth",
-  "version": "0.2.3",
-  "description": "Shared plumbing for the CortexKit auth plugins: loopback RPC, file locks and atomic writes, logger, sidebar state file, TUI preferences and TUI build.",
+  "version": "0.2.4",
+  "description": "Shared code for the CortexKit auth plugins: account pool, quota and routing, commands and auth menu, OpenCode 2 hooks, Claustrum custody, and plumbing (loopback RPC, file locks, logger, sidebar state, TUI preferences and build).",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -51,6 +51,30 @@
     "./routing": {
       "types": "./dist/routing/index.d.ts",
       "import": "./dist/routing/index.js"
+    },
+    "./commands": {
+      "types": "./dist/commands/index.d.ts",
+      "import": "./dist/commands/index.js"
+    },
+    "./auth-menu": {
+      "types": "./dist/auth-menu/index.d.ts",
+      "import": "./dist/auth-menu/index.js"
+    },
+    "./opencode2": {
+      "types": "./dist/opencode2/index.d.ts",
+      "import": "./dist/opencode2/index.js"
+    },
+    "./claustrum": {
+      "types": "./dist/claustrum/index.d.ts",
+      "import": "./dist/claustrum/index.js"
+    },
+    "./cachekeep": {
+      "types": "./dist/cachekeep/index.d.ts",
+      "import": "./dist/cachekeep/index.js"
+    },
+    "./dump": {
+      "types": "./dist/dump/index.d.ts",
+      "import": "./dist/dump/index.js"
     }
   },
   "files": [
@@ -73,7 +97,9 @@
   "peerDependencies": {
     "@opentui/core": ">=0.5.12",
     "@opentui/solid": ">=0.5.12",
-    "solid-js": "1.9.12"
+    "solid-js": "1.9.12",
+    "@cortexkit/claustrum-client": ">=0.5.0",
+    "@opencode/plugin": ">=2.0.21"
   },
   "peerDependenciesMeta": {
     "@opentui/core": {
@@ -84,10 +110,18 @@
     },
     "solid-js": {
       "optional": true
+    },
+    "@cortexkit/claustrum-client": {
+      "optional": true
+    },
+    "@opencode/plugin": {
+      "optional": true
     }
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.14",
+    "@cortexkit/claustrum-client": "0.5.0",
+    "@opencode/plugin": "2.0.21",
     "@opentui/core": ">=0.5.12",
     "@opentui/solid": ">=0.5.12",
     "@tsconfig/bun": "1.0.11",