@north-light/crouter 0.3.311 → 0.3.313

package/dist/core/scoped-state/settings.js

@@ -0,0 +1,82 @@
+import { createHash } from 'node:crypto';
+import { openScopedStore, withScopedWrite } from './db.js';
+function ensureOwner(db, owner) {
+    const row = db.prepare('SELECT kind, root, profile_id FROM scope_owners WHERE owner_key = ?').get(owner.key);
+    if (!row)
+        throw new Error(`scoped SQL owner is missing: ${owner.key}`);
+    if (row.kind !== owner.kind || row.root !== owner.root || (owner.profileId ?? null) !== row.profile_id) {
+        throw new Error(`scoped SQL owner does not match its root: ${owner.key}`);
+    }
+}
+function revisionFor(row) {
+    return row === undefined ? 'absent' : createHash('sha256').update(row.raw_json).digest('hex');
+}
+function readRawSettingsRow(db, owner) {
+    return db.prepare('SELECT raw_json FROM scope_settings WHERE owner_key = ?').get(owner.key);
+}
+export class SettingsRevisionConflictError extends Error {
+    constructor() {
+        super('settings changed since the supplied revision');
+        this.name = 'SettingsRevisionConflictError';
+    }
+}
+export function readRawSettingsWithRevision(owner) {
+    const db = openScopedStore(owner.store);
+    ensureOwner(db, owner);
+    const row = readRawSettingsRow(db, owner);
+    return { revision: revisionFor(row), settings: row === undefined ? null : JSON.parse(row.raw_json) };
+}
+export function readRawSettings(owner) {
+    return readRawSettingsWithRevision(owner).settings;
+}
+export function replaceRawSettings(owner, next, ifRevision, validate) {
+    return withScopedWrite(owner.store, (db) => {
+        ensureOwner(db, owner);
+        const current = readRawSettingsRow(db, owner);
+        if (ifRevision !== revisionFor(current))
+            throw new SettingsRevisionConflictError();
+        validate(next);
+        const rawJson = JSON.stringify(next);
+        if (current?.raw_json === rawJson)
+            return { revision: revisionFor(current), changed: false };
+        db.prepare(`INSERT INTO scope_settings(owner_key, raw_json) VALUES (?, ?) ON CONFLICT(owner_key) DO UPDATE SET raw_json=excluded.raw_json`).run(owner.key, rawJson);
+        return { revision: revisionFor({ raw_json: rawJson }), changed: true };
+    });
+}
+export function writeRawSettings(owner, raw) {
+    withScopedWrite(owner.store, (db) => {
+        ensureOwner(db, owner);
+        db.prepare(`INSERT INTO scope_settings(owner_key, raw_json) VALUES (?, ?) ON CONFLICT(owner_key) DO UPDATE SET raw_json=excluded.raw_json`).run(owner.key, JSON.stringify(raw));
+    });
+}
+export function mutateRawSettings(owner, mutate) {
+    return withScopedWrite(owner.store, (db) => {
+        ensureOwner(db, owner);
+        const row = db.prepare('SELECT raw_json FROM scope_settings WHERE owner_key = ?').get(owner.key);
+        const result = mutate(row ? JSON.parse(row.raw_json) : {});
+        db.prepare(`INSERT INTO scope_settings(owner_key, raw_json) VALUES (?, ?) ON CONFLICT(owner_key) DO UPDATE SET raw_json=excluded.raw_json`).run(owner.key, JSON.stringify(result.next));
+        return result.value;
+    });
+}
+export function readBookkeeping(owner) {
+    const db = openScopedStore(owner.store);
+    ensureOwner(db, owner);
+    const bookkeeping = db.prepare('SELECT last_self_check, active_canvas FROM scope_bookkeeping WHERE owner_key = ?').get(owner.key);
+    const marketplaces = Object.fromEntries(db.prepare('SELECT name, last_updated FROM scope_marketplaces WHERE owner_key = ?').all(owner.key).map((row) => [row.name, row.last_updated === null ? {} : { last_updated: row.last_updated }]));
+    const plugins = Object.fromEntries(db.prepare('SELECT name, last_updated, etag, checked_at FROM scope_plugins WHERE owner_key = ?').all(owner.key).map((row) => [row.name, { ...(row.last_updated === null ? {} : { last_updated: row.last_updated }), ...(row.etag === null ? {} : { etag: row.etag }), ...(row.checked_at === null ? {} : { checked_at: row.checked_at }) }]));
+    return { marketplaces, plugins, ...(bookkeeping?.last_self_check === null || bookkeeping === undefined ? {} : { last_self_check: bookkeeping.last_self_check }), activeCanvas: bookkeeping?.active_canvas ?? null };
+}
+export function writeBookkeeping(owner, state) {
+    withScopedWrite(owner.store, (db) => {
+        ensureOwner(db, owner);
+        db.prepare(`INSERT INTO scope_bookkeeping(owner_key, last_self_check, active_canvas) VALUES (?, ?, ?) ON CONFLICT(owner_key) DO UPDATE SET last_self_check=excluded.last_self_check, active_canvas=excluded.active_canvas`).run(owner.key, state.last_self_check ?? null, state.activeCanvas ?? null);
+        db.prepare('DELETE FROM scope_marketplaces WHERE owner_key = ?').run(owner.key);
+        db.prepare('DELETE FROM scope_plugins WHERE owner_key = ?').run(owner.key);
+        const market = db.prepare('INSERT INTO scope_marketplaces(owner_key, name, last_updated) VALUES (?, ?, ?)');
+        for (const [name, value] of Object.entries(state.marketplaces))
+            market.run(owner.key, name, value.last_updated ?? null);
+        const plugin = db.prepare('INSERT INTO scope_plugins(owner_key, name, last_updated, etag, checked_at) VALUES (?, ?, ?, ?, ?)');
+        for (const [name, value] of Object.entries(state.plugins))
+            plugin.run(owner.key, name, value.last_updated ?? null, value.etag ?? null, value.checked_at ?? null);
+    });
+}

package/dist/core/subscription-state.d.ts

@@ -2,12 +2,11 @@ export declare const ANTHROPIC_PROVIDER_ID = "anthropic";
 export declare const OPENAI_CODEX_PROVIDER_ID = "openai-codex";
 export declare const INVALID_REFRESH_TOKEN_BACKOFF_MS: number;
 export type ManagedProviderId = typeof ANTHROPIC_PROVIDER_ID | typeof OPENAI_CODEX_PROVIDER_ID;
-export type ModelStrength = "ultra" | "strong" | "medium" | "light";
+export type ModelStrength = 'ultra' | 'strong' | 'medium' | 'light';
 export type RotationConfig = {
     defaultFallbackStrength?: ModelStrength;
     revertWhenAvailable?: boolean;
 };
-type RotationConfigUpdate = RotationConfig;
 export type SubscriptionCredential = {
     label: string;
     refresh: string;
@@ -16,39 +15,26 @@ export type SubscriptionCredential = {
     rateLimitedUntil: number;
     lastAttemptAt: number;
     lastRateLimitedAt: number;
-    authFailure?: "invalid_grant";
+    authFailure?: 'invalid_grant';
     accountId?: string;
 };
-/** A concrete provider/model considered for either broker launch or turn-time rotation. */
 export type ProviderCandidate = {
     providerId: string;
     modelId: string;
     thinkingLevel?: string;
     registered: boolean;
     authenticated: boolean;
-    /** A provider is unavailable until this instant when every credential is cooling. */
     coolingUntil?: number;
-    /** False when this candidate may only be selected by an explicit request, never as fallback. */
     automaticFallback?: boolean;
-    /** Route provenance carried through selection diagnostics. */
     routeId?: string;
     credentialSource?: string;
     family?: string;
     strength?: ModelStrength;
     rank?: number;
 };
-export type ProviderCandidateRejection = "unregistered" | "non-managed-fallback" | "unauthenticated" | "cooling";
-/**
- * Select the first viable model from an explicitly ordered set. Callers own ordering
- * (requested model first, then their configured fallback order) and side effects;
- * this policy owns the shared viability rules so launch and rotation cannot diverge.
- *
- * `pinnedToFirst` marks the FIRST candidate as an explicit provider pin: the caller
- * demanded that exact provider, so an unregistered or unauthenticated first candidate
- * forbids cross-provider fallback (selection stops, reporting only that one rejection).
- * A merely COOLING pin is transient, so fallback to a viable alternative is still
- * allowed. When false, every candidate is considered in order.
- */
+export type ProviderCandidateRejection = 'unregistered' | 'non-managed-fallback' | 'unauthenticated' | 'cooling';
+export declare function isManagedProvider(providerId: string | undefined): providerId is ManagedProviderId;
+export declare function getProviderLabel(providerId: ManagedProviderId): string;
 export declare function resolveProviderCandidates(candidates: readonly ProviderCandidate[], now?: number, options?: {
     pinnedToFirst?: boolean;
 }): {
@@ -58,40 +44,44 @@ export declare function resolveProviderCandidates(candidates: readonly ProviderC
         reason: ProviderCandidateRejection;
     }>;
 };
-export declare function isManagedProvider(providerId: string | undefined): providerId is ManagedProviderId;
-export declare function getProviderLabel(providerId: ManagedProviderId): string;
-export declare function mutateSubscriptionPool(providerId: ManagedProviderId, fn: (pool: SubscriptionCredential[], assertLockHeld: () => void) => SubscriptionCredential[] | undefined | Promise<SubscriptionCredential[] | undefined>): Promise<SubscriptionCredential[]>;
-export declare function refreshSubscriptionCredential(providerId: ManagedProviderId, label: string, exchange: (refreshToken: string) => Promise<{
+export declare class DuplicateSubscriptionError extends Error {
+    constructor(message: string);
+}
+export declare function readSubscriptionPool(provider: ManagedProviderId): SubscriptionCredential[];
+export declare function writeSubscriptionPool(provider: ManagedProviderId, next: SubscriptionCredential[]): Promise<SubscriptionCredential[]>;
+export declare function addSubscription(provider: ManagedProviderId, entry: SubscriptionCredential): Promise<SubscriptionCredential[]>;
+export declare function upsertSubscription(provider: ManagedProviderId, entry: SubscriptionCredential): Promise<SubscriptionCredential[]>;
+export declare function upsertSubscriptionWithUniqueAccount(provider: ManagedProviderId, entry: SubscriptionCredential): Promise<SubscriptionCredential[]>;
+export declare function renameSubscription(provider: ManagedProviderId, ref: string, nextLabel: string): Promise<SubscriptionCredential[]>;
+export declare function removeManagedAccount(provider: ManagedProviderId, ref: string): Promise<SubscriptionCredential[]>;
+export declare function removeSubscription(provider: ManagedProviderId, ref: string): Promise<SubscriptionCredential[]>;
+export declare function removeAllManagedAccounts(provider: ManagedProviderId): Promise<number>;
+export declare function removeManagedProvider(provider: ManagedProviderId, label?: string): Promise<SubscriptionCredential[]>;
+export declare function promoteSubscription(provider: ManagedProviderId, ref: string): Promise<SubscriptionCredential[]>;
+export declare function markSubscriptionAttempt(provider: ManagedProviderId, ref: string, attemptAt?: number): Promise<SubscriptionCredential[]>;
+export declare function markSubscriptionAuthenticationFailed(provider: ManagedProviderId, ref: string, retryAfterMs: number, attemptAt?: number): Promise<SubscriptionCredential[]>;
+export declare function markSubscriptionRateLimited(provider: ManagedProviderId, ref: string, retryAfterMs: number, attemptAt?: number, rateLimitedAt?: number): Promise<SubscriptionCredential[]>;
+export declare function markSubscriptionSuccess(provider: ManagedProviderId, ref: string, attemptAt?: number): Promise<SubscriptionCredential[]>;
+export declare function refreshSubscriptionCredential(provider: ManagedProviderId, label: string, exchange: (refreshToken: string) => Promise<{
     refresh: string;
     access: string;
     expires: number;
 }>): Promise<SubscriptionCredential>;
 export declare function isInvalidRefreshTokenError(error: unknown): boolean;
-export declare function modifyElectedSubscription(providerId: ManagedProviderId, elect: (pool: SubscriptionCredential[]) => SubscriptionCredential | undefined, apply: (current: SubscriptionCredential) => Promise<{
+export declare function modifyElectedSubscription(provider: ManagedProviderId, elect: (pool: SubscriptionCredential[]) => SubscriptionCredential | undefined, apply: (current: SubscriptionCredential) => Promise<{
     refresh: string;
     access: string;
     expires: number;
 } | undefined>): Promise<SubscriptionCredential | undefined>;
-export declare function readSubscriptionPool(providerId: ManagedProviderId): SubscriptionCredential[];
-export declare function writeSubscriptionPool(providerId: ManagedProviderId, next: SubscriptionCredential[]): Promise<SubscriptionCredential[]>;
-export declare function upsertSubscription(providerId: ManagedProviderId, next: SubscriptionCredential): Promise<SubscriptionCredential[]>;
-export declare class DuplicateSubscriptionError extends Error {
-    constructor(message: string);
-}
-export declare function addSubscription(providerId: ManagedProviderId, entry: SubscriptionCredential): Promise<SubscriptionCredential[]>;
-export declare function upsertSubscriptionWithUniqueAccount(providerId: ManagedProviderId, next: SubscriptionCredential): Promise<SubscriptionCredential[]>;
-export declare function renameSubscription(providerId: ManagedProviderId, ref: string, nextLabel: string): Promise<SubscriptionCredential[]>;
-export declare function removeManagedAccount(providerId: ManagedProviderId, ref: string): Promise<SubscriptionCredential[]>;
 export type ManagedLoginIdentity = {
     accountId?: string;
     email?: string;
 };
-/** Fetch Anthropic's stable OAuth account identity without making login depend on it. */
-export declare function enrichManagedLoginIdentity(providerId: ManagedProviderId, credential: {
+export declare function enrichManagedLoginIdentity(provider: ManagedProviderId, value: {
     access: string;
     accountId?: string;
 }): Promise<ManagedLoginIdentity>;
-export declare function commitManagedLogin(providerId: ManagedProviderId, label: string | undefined, credential: {
+export declare function commitManagedLogin(provider: ManagedProviderId, label: string | undefined, value: {
     refresh: string;
     access: string;
     expires: number;
@@ -99,16 +89,7 @@ export declare function commitManagedLogin(providerId: ManagedProviderId, label:
     lastRateLimitedAt: number;
     autoLabel?: boolean;
 }): Promise<SubscriptionCredential[]>;
-export declare function removeAllManagedAccounts(providerId: ManagedProviderId): Promise<number>;
-export declare function removeManagedProvider(providerId: ManagedProviderId, label?: string): Promise<SubscriptionCredential[]>;
-export declare function removeSubscription(providerId: ManagedProviderId, ref: string): Promise<SubscriptionCredential[]>;
-export declare function promoteSubscription(providerId: ManagedProviderId, ref: string): Promise<SubscriptionCredential[]>;
-export declare function markSubscriptionAttempt(providerId: ManagedProviderId, ref: string, attemptAt?: number): Promise<SubscriptionCredential[]>;
-export declare function markSubscriptionAuthenticationFailed(providerId: ManagedProviderId, ref: string, retryAfterMs: number, attemptAt?: number): Promise<SubscriptionCredential[]>;
-export declare function markSubscriptionRateLimited(providerId: ManagedProviderId, ref: string, retryAfterMs: number, attemptAt?: number, rateLimitedAt?: number): Promise<SubscriptionCredential[]>;
-export declare function markSubscriptionSuccess(providerId: ManagedProviderId, ref: string, attemptAt?: number): Promise<SubscriptionCredential[]>;
 export declare function parseRetryAfterHeader(value: string | undefined, now?: number): number | undefined;
 export declare function readRotationConfig(): RotationConfig;
-export declare function writeRotationConfig(next: RotationConfigUpdate): RotationConfig;
-export declare function formatStatusLine(providerId: ManagedProviderId, now?: number): string;
-export {};
+export declare function writeRotationConfig(next: RotationConfig): RotationConfig;
+export declare function formatStatusLine(provider: ManagedProviderId, now?: number): string;