@crouter/api 0.3.387 → 0.3.389

package/dist/core/scoped-state/schema.d.ts

@@ -0,0 +1,6 @@
+import type { DatabaseSync } from 'node:sqlite';
+export declare const SCOPED_SCHEMA_VERSION = 5;
+export declare const PROVIDER_SCHEMA_VERSION = 1;
+/** Adds the model-cooldown table to a provider store that predates it; a no-op (no write) once present. */
+export declare function ensureProviderModelCooldowns(db: DatabaseSync): void;
+export declare function createScopedSchema(db: DatabaseSync, kind: 'user' | 'project' | 'provider'): void;

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

@@ -0,0 +1,43 @@
+import { prepared as cachedStatement } from '../sqlite-statements.js';
+export const SCOPED_SCHEMA_VERSION = 5;
+export const PROVIDER_SCHEMA_VERSION = 1;
+const SCOPE_SCHEMA = `
+CREATE TABLE scope_owners (owner_key TEXT PRIMARY KEY, kind TEXT NOT NULL CHECK(kind IN ('user','profile','project')), root TEXT NOT NULL UNIQUE, profile_id TEXT UNIQUE);
+CREATE TABLE profiles (id TEXT PRIMARY KEY, name TEXT NOT NULL, created_at TEXT NOT NULL, last_used_at TEXT, paused_at TEXT, default_kind TEXT, grantee TEXT, metadata_json TEXT NOT NULL CHECK(json_valid(metadata_json)), delivery_limits_json TEXT NOT NULL DEFAULT '{}' CHECK(json_valid(delivery_limits_json)));
+CREATE TABLE profile_projects (profile_id TEXT NOT NULL REFERENCES profiles(id) ON DELETE CASCADE, path TEXT NOT NULL, position INTEGER NOT NULL, PRIMARY KEY(profile_id,path), UNIQUE(profile_id,position));
+-- Pre-canvas per-project memory caps awaiting the canvas import, which turns them into delivery_limits and deletes the rows.
+CREATE TABLE legacy_project_caps (profile_id TEXT NOT NULL, path TEXT NOT NULL, memory TEXT NOT NULL CHECK(memory IN ('none','name','preview')), PRIMARY KEY(profile_id,path));
+CREATE TABLE profile_defaults (directory TEXT PRIMARY KEY, profile_id TEXT NOT NULL REFERENCES profiles(id) ON DELETE CASCADE);
+CREATE TABLE scope_settings (owner_key TEXT PRIMARY KEY REFERENCES scope_owners(owner_key), raw_json TEXT NOT NULL CHECK(json_valid(raw_json)));
+CREATE TABLE scope_bookkeeping (owner_key TEXT PRIMARY KEY REFERENCES scope_owners(owner_key), last_self_check TEXT, active_canvas TEXT);
+CREATE TABLE scope_marketplaces (owner_key TEXT NOT NULL REFERENCES scope_owners(owner_key), name TEXT NOT NULL, last_updated TEXT, PRIMARY KEY(owner_key,name));
+CREATE TABLE scope_plugins (owner_key TEXT NOT NULL REFERENCES scope_owners(owner_key), name TEXT NOT NULL, last_updated TEXT, etag TEXT, checked_at TEXT, PRIMARY KEY(owner_key,name));`;
+// A subscription 429 on one model family's window (Anthropic `seven_day_opus` /
+// `seven_day_sonnet`) cools only that family on that account. Additive to v1: a
+// store written before this table existed gains it on open (ensureProviderModelCooldowns),
+// and older crtr generations sharing the store simply never read it, so the provider
+// schema version stays 1 and a runtime rollback keeps opening the store.
+const MODEL_COOLDOWNS_TABLE = 'CREATE TABLE IF NOT EXISTS managed_account_model_cooldowns (provider_id TEXT NOT NULL, account_id TEXT NOT NULL, family TEXT NOT NULL, rate_limited_until INTEGER NOT NULL, last_rate_limited_at INTEGER NOT NULL, PRIMARY KEY(provider_id,account_id,family));';
+/** Adds the model-cooldown table to a provider store that predates it; a no-op (no write) once present. */
+export function ensureProviderModelCooldowns(db) {
+    const present = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='managed_account_model_cooldowns'").get();
+    if (present === undefined)
+        db.exec(MODEL_COOLDOWNS_TABLE);
+}
+const PROVIDER_SCHEMA = `
+CREATE TABLE managed_accounts (provider_id TEXT NOT NULL, id TEXT NOT NULL, label TEXT NOT NULL, label_key TEXT NOT NULL, position INTEGER NOT NULL, last_attempt_at INTEGER NOT NULL, last_rate_limited_at INTEGER NOT NULL, rate_limited_until INTEGER NOT NULL, auth_failure TEXT CHECK(auth_failure IS NULL OR auth_failure='invalid_grant'), PRIMARY KEY(provider_id,id), UNIQUE(provider_id,label_key));
+CREATE INDEX managed_accounts_order ON managed_accounts(provider_id,position);
+CREATE TABLE rotation_settings (singleton INTEGER PRIMARY KEY CHECK(singleton=1), default_fallback_strength TEXT, revert_when_available INTEGER CHECK(revert_when_available IN (0,1)));
+CREATE TABLE provider_revision (singleton INTEGER PRIMARY KEY CHECK(singleton=1), revision INTEGER NOT NULL);
+${MODEL_COOLDOWNS_TABLE}`;
+export function createScopedSchema(db, kind) {
+    db.exec(kind === 'provider' ? PROVIDER_SCHEMA : SCOPE_SCHEMA);
+    if (kind !== 'provider') {
+        const ownerKey = kind === 'user' ? 'user' : 'project';
+        cachedStatement(db, 'INSERT INTO scope_owners(owner_key, kind, root, profile_id) VALUES (?, ?, ?, NULL)').run(ownerKey, kind, '');
+    }
+    else {
+        cachedStatement(db, 'INSERT INTO provider_revision(singleton, revision) VALUES (1, 0)').run();
+    }
+    db.exec(`PRAGMA user_version = ${kind === 'provider' ? PROVIDER_SCHEMA_VERSION : SCOPED_SCHEMA_VERSION}`);
+}

package/dist/core/scoped-state/settings.d.ts

@@ -0,0 +1,28 @@
+import type { ScopeState } from '../../types.js';
+import type { ScopedStore } from './paths.js';
+export type SettingsOwner = {
+    store: ScopedStore;
+    key: string;
+    kind: 'user' | 'profile' | 'project';
+    root: string;
+    profileId?: string;
+};
+export declare class SettingsRevisionConflictError extends Error {
+    constructor();
+}
+export declare function readRawSettingsWithRevision(owner: SettingsOwner): {
+    settings: Record<string, unknown> | null;
+    revision: string;
+};
+export declare function readRawSettings(owner: SettingsOwner): Record<string, unknown> | null;
+export declare function replaceRawSettings(owner: SettingsOwner, next: Record<string, unknown>, ifRevision: string, validate: (settings: Record<string, unknown>) => void): {
+    revision: string;
+    changed: boolean;
+};
+export declare function writeRawSettings(owner: SettingsOwner, raw: Record<string, unknown>): void;
+export declare function mutateRawSettings<T>(owner: SettingsOwner, mutate: (current: Record<string, unknown>) => {
+    value: T;
+    next: Record<string, unknown>;
+}): T;
+export declare function readBookkeeping(owner: SettingsOwner): ScopeState;
+export declare function writeBookkeeping(owner: SettingsOwner, state: ScopeState): void;

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

@@ -0,0 +1,83 @@
+import { prepared as cachedStatement } from '../sqlite-statements.js';
+import { createHash } from 'node:crypto';
+import { openScopedStore, withScopedWrite } from './db.js';
+function ensureOwner(db, owner) {
+    const row = cachedStatement(db, '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 cachedStatement(db, '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 };
+        cachedStatement(db, `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);
+        cachedStatement(db, `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 = cachedStatement(db, 'SELECT raw_json FROM scope_settings WHERE owner_key = ?').get(owner.key);
+        const result = mutate(row ? JSON.parse(row.raw_json) : {});
+        cachedStatement(db, `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 = cachedStatement(db, 'SELECT last_self_check, active_canvas FROM scope_bookkeeping WHERE owner_key = ?').get(owner.key);
+    const marketplaces = Object.fromEntries(cachedStatement(db, '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(cachedStatement(db, '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);
+        cachedStatement(db, `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);
+        cachedStatement(db, 'DELETE FROM scope_marketplaces WHERE owner_key = ?').run(owner.key);
+        cachedStatement(db, 'DELETE FROM scope_plugins WHERE owner_key = ?').run(owner.key);
+        const market = cachedStatement(db, '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 = cachedStatement(db, '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/spaces/open-beneath.d.ts

@@ -0,0 +1,71 @@
+import { type Dirent, type Stats } from 'node:fs';
+export declare function isBeneathRefusal(error: unknown): boolean;
+/** Whether a beneath read failed because nothing usable is there: absent, not a
+ *  directory, unreadable, or refused (see `BeneathRefusal`). */
+export declare function isAbsentOrRefused(error: unknown): boolean;
+/** An fd for `path` opened with `flags`, resolved beneath `root`. Never creates:
+ *  `openat2` takes no mode, so a file it created would be mode 0000. On Linux
+ *  the fd is a regular file or a directory, except with O_PATH, which opens
+ *  nothing and is only stat'd. */
+export declare function openBeneath(root: string, path: string, flags: number): number;
+export declare function readFileBeneath(root: string, path: string): Buffer;
+/** The file's text, or null when it is missing or refused. */
+export declare function readTextBeneathIfExists(root: string, path: string): string | null;
+export declare function statBeneath(root: string, path: string): Stats;
+export declare function existsBeneath(root: string, path: string): boolean;
+/** Run `fn` with `at(name)`, a pathname that reaches one entry of `dir` after
+ *  `dir` itself resolved beneath `root` (`at()` is the directory). With
+ *  `create`, missing directories on the way are made. */
+export declare function withDirBeneath<T>(root: string, dir: string, fn: (at: (name?: string) => string) => T, create?: boolean): T;
+/** Write `data` to `path` beneath `root`, making missing parents. `atomic`
+ *  writes a temporary file and renames it over the target, so on Linux a
+ *  symlink at the target is replaced, never followed. A Mac writes through a
+ *  symlink to its target, as it always has (a dangling one fails ENOENT). */
+export declare function writeFileBeneath(root: string, path: string, data: Buffer | string, options?: {
+    mode?: number;
+    atomic?: boolean;
+}): void;
+/** Create `path` beneath `root` only if absent (`wx`), making missing parents. */
+export declare function createFileBeneath(root: string, path: string, data: Buffer | string, mode?: number): void;
+export declare function appendFileBeneath(root: string, path: string, data: string): void;
+export declare function unlinkBeneath(root: string, path: string): void;
+export declare function rmdirBeneath(root: string, path: string): void;
+export declare function renameBeneath(root: string, from: string, to: string): void;
+/** link(2) without replacement: fails if `to` exists. */
+export declare function linkBeneath(root: string, from: string, to: string): void;
+export declare function fsyncDirBeneath(root: string, dir: string): void;
+/** Directory entries typed by the directory itself (a symlink stays a symlink). */
+export declare function readdirBeneath(root: string, dir: string): Dirent[];
+/** The first `limit` entries by name, each with its own (unfollowed on Linux)
+ *  stat; an entry removed before its stat is left out. */
+export declare function listBeneath(root: string, dir: string, limit: number): Array<{
+    name: string;
+    stat: Stats;
+}>;
+/** Regular files under `dir` matching `predicate`, never descending a symlink. */
+export declare function walkFilesBeneath(root: string, dir: string, predicate?: (name: string) => boolean, skipDir?: (name: string) => boolean): string[];
+/** Copy the entries of `from` (beneath `fromRoot`) into `to` (beneath
+ *  `toRoot`): directories and regular files with their permission bits, and
+ *  symlinks as links, never followed. Any other entry, any entry removed or
+ *  refused after the directory was read, and any top-level name in `skip`, is
+ *  left out. A name `to` already holds is overwritten, except by a symlink. */
+export declare function copyTreeBeneath(fromRoot: string, from: string, toRoot: string, to: string, skip?: ReadonlySet<string>): void;
+/** Set the mode (and, with `owner`, the owner) of the file or directory at
+ *  `path` beneath `root` through an fd opened without following a symlink. A
+ *  Mac sets them by pathname, as it always has. */
+export declare function setModeBeneath(root: string, path: string, mode: number, owner?: {
+    uid: number;
+    gid: number;
+}): void;
+/** Remove the tree at `path` beneath `root`, never descending a symlink: a
+ *  symlink at `path` or inside it is unlinked itself. Absent is not an error.
+ *  On Linux the walk holds one directory fd per level and opens each child
+ *  relative to its parent, so a deep tree costs one open per entry. */
+export declare function removeTreeBeneath(root: string, path: string): void;
+/** A pathname that connects to the unix socket at `path` beneath `root`
+ *  without following a symlink, and `release`, to call once the connect has
+ *  settled. On Linux it is the magic link of an O_PATH fd held until release. */
+export declare function socketBeneath(root: string, path: string): {
+    path: string;
+    release: () => void;
+};