@north-light/api 0.3.561 → 0.3.563

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

@@ -1,187 +0,0 @@
-import { prepared as cachedStatement } from '../sqlite-statements.js';
-import { randomUUID } from 'node:crypto';
-import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import { dirname, join, relative } from 'node:path';
-import lockfile from 'proper-lockfile';
-import { CONFIG_FILE, PROFILE_DIR, STATE_FILE } from '../../types.js';
-import { LockedJsonFile } from '../locked-file.js';
-import { assertScopedStoreReady, createScopedStore, discardIncompleteScopedStore, legacyScopedStorePaths, PROFILE_ID_SHAPE, scopedStoreExists, withProjectStateLock, writeOwnerRoot } from './db.js';
-import { canonicalRoot, providerStore, projectStore, userStore } from './paths.js';
-import { profileSpace } from '../layout.js';
-import { createScopedSchema } from './schema.js';
-function json(path) { return JSON.parse(readFileSync(path, 'utf8')); }
-function existsLegacy(paths) { return paths.some(existsSync); }
-function preserve(root, paths) { const target = join(root, '.legacy-scoped-state'); try {
-    mkdirSync(target, { mode: 0o700 });
-}
-catch (error) {
-    if (error.code !== 'EEXIST' || !statSync(target).isDirectory())
-        throw error;
-} chmodSync(target, 0o700); for (const path of paths)
-    if (existsSync(path) && statSync(path).isFile()) {
-        const fromRoot = relative(root, path);
-        if (fromRoot === '' || fromRoot.startsWith('..'))
-            throw new Error(`legacy state is outside its owning root: ${path}`);
-        const destination = join(target, fromRoot);
-        if (dirname(destination) !== target)
-            mkdirSync(dirname(destination), { recursive: true, mode: 0o700 });
-        copyFileSync(path, destination);
-        chmodSync(destination, 0o600);
-    } }
-export { initializeFreshScopedStore } from './db.js';
-/** Conversion is intentionally explicit. Deployment coordination must prove all legacy writers at these shared roots are stopped before calling it. */
-export function convertLegacyScopedStore(input) {
-    const store = input.kind === 'user' ? userStore(input.root) : input.kind === 'project' ? projectStore(input.root) : providerStore(input.root);
-    if (input.kind !== 'project' && scopedStoreExists(store))
-        return;
-    if (input.kind === 'provider')
-        throw new Error('provider conversion requires convertLegacyProviderStore() under coordinated shared-agent-dir activation');
-    const paths = legacyScopedStorePaths(store);
-    const convert = () => {
-        if (input.kind === 'project')
-            discardIncompleteScopedStore(store);
-        if (scopedStoreExists(store))
-            return;
-        if (input.kind === 'project' && existsLegacy(paths))
-            preserve(store.root, paths);
-        createScopedStore(store, (db) => {
-            createScopedSchema(db, input.kind);
-            const owner = input.kind === 'user' ? 'user' : 'project';
-            writeOwnerRoot(db, owner, store.root);
-            if (input.kind === 'user')
-                importUser(db, store.root);
-            else
-                importState(db, owner, join(store.root, STATE_FILE));
-        });
-        if (input.kind === 'user' && existsLegacy(paths))
-            preserve(store.root, paths);
-    };
-    if (input.kind === 'project')
-        withProjectStateLock(store.root, () => { convert(); assertScopedStoreReady(store); });
-    else
-        convert();
-}
-function parseLegacyProviderPool(path) {
-    if (!existsSync(path))
-        return [];
-    const raw = JSON.parse(readFileSync(path, 'utf8'));
-    if (!Array.isArray(raw))
-        throw new Error(`legacy subscription pool is malformed: ${path}`);
-    const labels = new Set();
-    return raw.map((item, position) => {
-        if (item === null || typeof item !== 'object' || Array.isArray(item))
-            throw new Error(`legacy subscription pool entry ${position + 1} is malformed: ${path}`);
-        const value = item;
-        const label = typeof value.label === 'string' ? value.label.trim() : '';
-        const refresh = typeof value.refresh === 'string' ? value.refresh.trim() : '';
-        const access = typeof value.access === 'string' ? value.access.trim() : '';
-        const expires = Number(value.expires);
-        if (!label || !refresh || !access || !Number.isFinite(expires))
-            throw new Error(`legacy subscription pool entry ${position + 1} is incomplete: ${path}`);
-        const labelKey = label.toLowerCase();
-        if (labels.has(labelKey))
-            throw new Error(`legacy subscription pool has duplicate label "${label}": ${path}`);
-        labels.add(labelKey);
-        const timing = (field) => Number.isFinite(Number(value[field])) ? Number(value[field]) : 0;
-        const accountId = typeof value.accountId === 'string' && value.accountId.trim() !== '' ? value.accountId.trim() : undefined;
-        return { label, refresh, access, expires, rateLimitedUntil: timing('rateLimitedUntil'), lastAttemptAt: timing('lastAttemptAt'), lastRateLimitedAt: timing('lastRateLimitedAt'), ...(value.authFailure === 'invalid_grant' ? { authFailure: 'invalid_grant' } : {}), ...(accountId ? { accountId } : {}) };
-    });
-}
-function parseLegacyRotation(path) {
-    if (!existsSync(path))
-        return {};
-    const raw = JSON.parse(readFileSync(path, 'utf8'));
-    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
-        throw new Error(`legacy provider rotation settings are malformed: ${path}`);
-    const value = raw;
-    return { ...(value.defaultFallbackStrength === 'ultra' || value.defaultFallbackStrength === 'strong' || value.defaultFallbackStrength === 'medium' || value.defaultFallbackStrength === 'light' ? { defaultFallbackStrength: value.defaultFallbackStrength } : {}), ...(typeof value.revertWhenAvailable === 'boolean' ? { revertWhenAvailable: value.revertWhenAvailable } : {}) };
-}
-async function withLegacyProviderLocks(paths, run) {
-    const releases = [];
-    try {
-        for (const path of paths)
-            if (existsSync(path))
-                releases.push(await lockfile.lock(path, { realpath: false, retries: 0, stale: 30_000, update: 10_000 }));
-        return await run();
-    }
-    finally {
-        await Promise.allSettled(releases.reverse().map((release) => release()));
-    }
-}
-/** Converts legacy provider pools only after the activation owner has stopped every writer sharing this agent directory. */
-export async function convertLegacyProviderStore(agentDir) {
-    const store = providerStore(agentDir);
-    if (scopedStoreExists(store))
-        return;
-    const paths = legacyScopedStorePaths(store);
-    await withLegacyProviderLocks(paths, async () => {
-        if (scopedStoreExists(store))
-            return;
-        const pools = new Map(paths.slice(0, 2).map((path, index) => [index === 0 ? 'anthropic' : 'openai-codex', parseLegacyProviderPool(path)]));
-        const rotation = parseLegacyRotation(paths[2]);
-        mkdirSync(store.root, { recursive: true, mode: 0o700 });
-        preserve(store.root, paths);
-        for (const [provider, pool] of pools) {
-            const accounts = Object.fromEntries(pool.map((entry) => { const id = randomUUID(); return [id, { refresh: entry.refresh, access: entry.access, expires: entry.expires, ...(entry.accountId ? { accountId: entry.accountId } : {}) }]; }));
-            const file = new LockedJsonFile(join(store.root, `${provider}-credentials.json`), true, '{"version":1,"accounts":{}}\n');
-            await file.withLockAsync(async (_current, _held, publish) => { publish(`${JSON.stringify({ version: 1, accounts })}\n`); return { result: undefined }; });
-        }
-        createScopedStore(store, (db) => {
-            createScopedSchema(db, 'provider');
-            for (const [provider, pool] of pools) {
-                const accounts = JSON.parse(readFileSync(join(store.root, `${provider}-credentials.json`), 'utf8'));
-                const ids = Object.keys(accounts.accounts);
-                const insert = cachedStatement(db, 'INSERT INTO managed_accounts(provider_id,id,label,label_key,position,last_attempt_at,last_rate_limited_at,rate_limited_until,auth_failure) VALUES(?,?,?,?,?,?,?,?,?)');
-                pool.forEach((entry, position) => insert.run(provider, ids[position], entry.label, entry.label.toLowerCase(), position, entry.lastAttemptAt, entry.lastRateLimitedAt, entry.rateLimitedUntil, entry.authFailure ?? null));
-            }
-            if (rotation.defaultFallbackStrength !== undefined || rotation.revertWhenAvailable !== undefined)
-                cachedStatement(db, 'INSERT INTO rotation_settings(singleton,default_fallback_strength,revert_when_available) VALUES(1,?,?)').run(rotation.defaultFallbackStrength ?? null, rotation.revertWhenAvailable === undefined ? null : rotation.revertWhenAvailable ? 1 : 0);
-        });
-    });
-}
-function importSettings(db, owner, path) { if (!existsSync(path))
-    return; const raw = json(path); if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
-    throw new Error(`legacy config is malformed: ${path}`); cachedStatement(db, 'INSERT INTO scope_settings(owner_key,raw_json) VALUES(?,?)').run(owner, JSON.stringify(raw)); }
-function importState(db, owner, path) { if (!existsSync(path))
-    return; const raw = json(path); if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
-    throw new Error(`legacy state is malformed: ${path}`); const state = raw; cachedStatement(db, 'INSERT INTO scope_bookkeeping(owner_key,last_self_check,active_canvas) VALUES(?,?,?)').run(owner, state.last_self_check ?? null, state.activeCanvas ?? null); 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, name, value.last_updated ?? null); const plugins = cachedStatement(db, 'INSERT INTO scope_plugins(owner_key,name,last_updated,etag,checked_at) VALUES(?,?,?,?,?)'); for (const [name, value] of Object.entries(state.plugins ?? {}))
-    plugins.run(owner, name, value.last_updated ?? null, value.etag ?? null, value.checked_at ?? null); }
-function importUser(db, root) {
-    importSettings(db, 'user', join(root, CONFIG_FILE));
-    importState(db, 'user', join(root, STATE_FILE));
-    const profiles = join(root, PROFILE_DIR);
-    if (existsSync(profiles))
-        for (const entry of readdirSync(profiles, { withFileTypes: true })) {
-            if (!entry.isDirectory() || !PROFILE_ID_SHAPE.test(entry.name))
-                continue;
-            const id = entry.name;
-            const profileRoot = join(profiles, id);
-            const path = join(profileRoot, 'profile.json');
-            if (!existsSync(path))
-                throw new Error(`legacy profile manifest is missing: ${path}`);
-            const manifest = json(path);
-            if (!manifest || typeof manifest !== 'object' || !Array.isArray(manifest.projects) || typeof manifest.name !== 'string' || typeof manifest.created_at !== 'string')
-                throw new Error(`legacy profile manifest is malformed: ${path}`);
-            cachedStatement(db, 'INSERT INTO profiles(id,name,created_at,last_used_at,paused_at,default_kind,grantee,metadata_json) VALUES(?,?,?,?,?,?,?,?)').run(id, manifest.name, manifest.created_at, manifest.last_used_at ?? null, manifest.paused_at ?? null, manifest.default_kind ?? null, manifest.grantee ?? null, JSON.stringify(manifest.metadata ?? {}));
-            cachedStatement(db, 'INSERT INTO scope_owners(owner_key,kind,root,profile_id) VALUES(?,?,?,?)').run(`profile:${id}`, 'profile', canonicalRoot(profileSpace(manifest.grantee ?? 'app:terminal', id).dir), id);
-            const project = cachedStatement(db, 'INSERT INTO profile_projects(profile_id,path,position) VALUES(?,?,?)');
-            const cap = cachedStatement(db, 'INSERT INTO legacy_project_caps(profile_id,path,memory) VALUES(?,?,?)');
-            manifest.projects.forEach((p, position) => { project.run(id, p.path, position); if (p.memory !== undefined && p.memory !== 'content')
-                cap.run(id, p.path, p.memory); });
-            importSettings(db, `profile:${id}`, join(profileRoot, CONFIG_FILE));
-            importState(db, `profile:${id}`, join(profileRoot, STATE_FILE));
-        }
-    const defaults = join(root, 'profile-defaults.json');
-    if (existsSync(defaults)) {
-        const raw = json(defaults);
-        if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
-            throw new Error(`legacy profile defaults are malformed: ${defaults}`);
-        const insert = cachedStatement(db, 'INSERT INTO profile_defaults(directory,profile_id) VALUES(?,?)');
-        for (const [directory, id] of Object.entries(raw)) {
-            if (typeof id !== 'string')
-                throw new Error(`legacy profile default is malformed: ${defaults}`);
-            insert.run(directory, id);
-        }
-    }
-}

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

@@ -1,27 +0,0 @@
-import type { ProfileManifest } from '../../types.js';
-export type StoredProfile = {
-    profileId: string;
-    manifest: ProfileManifest;
-};
-export declare function listStoredProfiles(root: string): StoredProfile[];
-export declare function getStoredProfile(root: string, id: string): StoredProfile | null;
-/** Pause gates need only this column; do not hydrate projects or JSON manifests. */
-export declare function profilePaused(root: string, id: string): boolean;
-export declare function pausedProfileIds(root: string): Set<string>;
-export declare function insertStoredProfile(root: string, profile: StoredProfile): void;
-export declare function updateStoredProfile(root: string, id: string, mutate: (current: ProfileManifest) => ProfileManifest): StoredProfile | null;
-export declare function deleteStoredProfile(root: string, id: string): boolean;
-export declare function rewriteLocalProfileGrantees(root: string): void;
-export declare function readStoredDefaults(root: string): Record<string, string>;
-export declare function mutateStoredDefaults(root: string, mutate: (current: Record<string, string>) => Record<string, string>): Record<string, string>;
-/** Pre-canvas per-project memory caps (`none|name|preview`) the canvas import has not converted yet. */
-export declare function listLegacyProjectCaps(root: string): Array<{
-    profileId: string;
-    path: string;
-    memory: string;
-}>;
-/** Store each converted profile's delivery limits and delete every legacy cap row, in one write. */
-export declare function commitConvertedProjectCaps(root: string, limits: ReadonlyArray<{
-    profileId: string;
-    deliveryLimits: Record<string, string>;
-}>): void;

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

@@ -1,94 +0,0 @@
-import { prepared as cachedStatement } from '../sqlite-statements.js';
-import { canonicalRoot, userStore } from './paths.js';
-import { profileSpace } from '../layout.js';
-import { openScopedStore, withScopedWrite } from './db.js';
-import { LEGACY_LOCAL_PERSON } from '../canvas/legacy-person.js';
-function store(root) { return userStore(root); }
-function rowToProfile(row, projects) {
-    return { profileId: row.id, manifest: { schema_version: 1, name: row.name, projects, paused_at: row.paused_at, ...(row.default_kind === null ? {} : { default_kind: row.default_kind }), ...(row.grantee === null ? {} : { grantee: row.grantee }), ...(row.environment_id === null ? {} : { environment_id: row.environment_id }), ...(row.delivery_limits_json === '{}' ? {} : { delivery_limits: JSON.parse(row.delivery_limits_json) }), ...(Object.keys(JSON.parse(row.metadata_json)).length === 0 ? {} : { metadata: JSON.parse(row.metadata_json) }), created_at: row.created_at, last_used_at: row.last_used_at } };
-}
-function get(db, id) {
-    const row = cachedStatement(db, 'SELECT id, name, created_at, last_used_at, paused_at, default_kind, grantee, metadata_json, delivery_limits_json, environment_id FROM profiles WHERE id=?').get(id);
-    if (!row)
-        return null;
-    const projects = cachedStatement(db, 'SELECT path FROM profile_projects WHERE profile_id=? ORDER BY position').all(id);
-    return rowToProfile(row, projects);
-}
-export function listStoredProfiles(root) {
-    const db = openScopedStore(store(root));
-    const ids = cachedStatement(db, 'SELECT id FROM profiles ORDER BY rowid').all();
-    return ids.map(({ id }) => get(db, id)).filter(Boolean);
-}
-export function getStoredProfile(root, id) { return get(openScopedStore(store(root)), id); }
-/** Pause gates need only this column; do not hydrate projects or JSON manifests. */
-export function profilePaused(root, id) {
-    const row = cachedStatement(openScopedStore(store(root)), 'SELECT paused_at FROM profiles WHERE id=?').get(id);
-    return row?.paused_at != null;
-}
-export function pausedProfileIds(root) {
-    const rows = cachedStatement(openScopedStore(store(root)), 'SELECT id FROM profiles WHERE paused_at IS NOT NULL').all();
-    return new Set(rows.map((row) => row.id));
-}
-export function insertStoredProfile(root, profile) {
-    withScopedWrite(store(root), (db) => {
-        cachedStatement(db, 'INSERT INTO profiles(id,name,created_at,last_used_at,paused_at,default_kind,grantee,metadata_json,delivery_limits_json,environment_id) VALUES(?,?,?,?,?,?,?,?,?,?)').run(profile.profileId, profile.manifest.name, profile.manifest.created_at, profile.manifest.last_used_at, profile.manifest.paused_at, profile.manifest.default_kind ?? null, profile.manifest.grantee ?? null, JSON.stringify(profile.manifest.metadata ?? {}), JSON.stringify(profile.manifest.delivery_limits ?? {}), profile.manifest.environment_id ?? null);
-        cachedStatement(db, 'INSERT INTO scope_owners(owner_key,kind,root,profile_id) VALUES(?,?,?,?)').run(`profile:${profile.profileId}`, 'profile', canonicalRoot(profileSpace(profile.manifest.grantee ?? 'app:terminal', profile.profileId).dir), profile.profileId);
-        const insert = cachedStatement(db, 'INSERT INTO profile_projects(profile_id,path,position) VALUES(?,?,?)');
-        profile.manifest.projects.forEach((project, position) => insert.run(profile.profileId, project.path, position));
-    });
-}
-export function updateStoredProfile(root, id, mutate) {
-    return withScopedWrite(store(root), (db) => {
-        const current = get(db, id);
-        if (!current)
-            return null;
-        const next = mutate(current.manifest);
-        cachedStatement(db, 'UPDATE profiles SET name=?, last_used_at=?, paused_at=?, default_kind=?, grantee=?, metadata_json=?, delivery_limits_json=?, environment_id=? WHERE id=?').run(next.name, next.last_used_at, next.paused_at, next.default_kind ?? null, next.grantee ?? null, JSON.stringify(next.metadata ?? {}), JSON.stringify(next.delivery_limits ?? {}), next.environment_id ?? null, id);
-        cachedStatement(db, 'DELETE FROM profile_projects WHERE profile_id=?').run(id);
-        const insert = cachedStatement(db, 'INSERT INTO profile_projects(profile_id,path,position) VALUES(?,?,?)');
-        next.projects.forEach((project, position) => insert.run(id, project.path, position));
-        return { profileId: id, manifest: next };
-    });
-}
-export function deleteStoredProfile(root, id) {
-    return withScopedWrite(store(root), (db) => {
-        if (!get(db, id))
-            return false;
-        const owner = `profile:${id}`;
-        cachedStatement(db, 'DELETE FROM scope_settings WHERE owner_key=?').run(owner);
-        cachedStatement(db, 'DELETE FROM scope_bookkeeping WHERE owner_key=?').run(owner);
-        cachedStatement(db, 'DELETE FROM scope_marketplaces WHERE owner_key=?').run(owner);
-        cachedStatement(db, 'DELETE FROM scope_plugins WHERE owner_key=?').run(owner);
-        cachedStatement(db, 'DELETE FROM scope_owners WHERE owner_key=?').run(owner);
-        cachedStatement(db, 'DELETE FROM profiles WHERE id=?').run(id);
-        return true;
-    });
-}
-export function rewriteLocalProfileGrantees(root) {
-    withScopedWrite(store(root), (db) => {
-        cachedStatement(db, "UPDATE profiles SET grantee = 'app:terminal' WHERE grantee = ?").run(LEGACY_LOCAL_PERSON);
-    });
-}
-export function readStoredDefaults(root) {
-    const db = openScopedStore(store(root));
-    return Object.fromEntries(cachedStatement(db, 'SELECT directory,profile_id FROM profile_defaults').all().map((row) => [row.directory, row.profile_id]));
-}
-export function mutateStoredDefaults(root, mutate) {
-    return withScopedWrite(store(root), (db) => { const current = Object.fromEntries(cachedStatement(db, 'SELECT directory,profile_id FROM profile_defaults').all().map((row) => [row.directory, row.profile_id])); const next = mutate(current); cachedStatement(db, 'DELETE FROM profile_defaults').run(); const insert = cachedStatement(db, 'INSERT INTO profile_defaults(directory,profile_id) VALUES(?,?)'); for (const [directory, id] of Object.entries(next))
-        insert.run(directory, id); return next; });
-}
-/** Pre-canvas per-project memory caps (`none|name|preview`) the canvas import has not converted yet. */
-export function listLegacyProjectCaps(root) {
-    return cachedStatement(openScopedStore(store(root)), 'SELECT profile_id, path, memory FROM legacy_project_caps ORDER BY profile_id, path').all()
-        .map((r) => ({ profileId: r.profile_id, path: r.path, memory: r.memory }));
-}
-/** Store each converted profile's delivery limits and delete every legacy cap row, in one write. */
-export function commitConvertedProjectCaps(root, limits) {
-    withScopedWrite(store(root), (db) => {
-        const set = cachedStatement(db, 'UPDATE profiles SET delivery_limits_json=? WHERE id=?');
-        for (const l of limits)
-            if (set.run(JSON.stringify(l.deliveryLimits), l.profileId).changes !== 1)
-                throw new Error(`no stored profile ${l.profileId}`);
-        cachedStatement(db, 'DELETE FROM legacy_project_caps').run();
-    });
-}

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

@@ -1,24 +0,0 @@
-import type { DatabaseSync } from 'node:sqlite';
-export type ProviderRow = {
-    providerId: string;
-    id: string;
-    label: string;
-    labelKey: string;
-    position: number;
-    lastAttemptAt: number;
-    lastRateLimitedAt: number;
-    rateLimitedUntil: number;
-    authFailure?: 'invalid_grant';
-};
-/** One model family's cooldown on one account (`managed_account_model_cooldowns`). */
-export type ProviderModelCooldown = {
-    family: string;
-    rateLimitedUntil: number;
-    lastRateLimitedAt: number;
-};
-export declare function providerRows(agentDir: string, providerId: string): ProviderRow[];
-export declare function providerRowByReference(db: DatabaseSync, providerId: string, ref: string): ProviderRow | undefined;
-export declare function providerModelCooldowns(db: DatabaseSync, providerId: string): Map<string, ProviderModelCooldown[]>;
-export declare function providerModelCooldownsFor(agentDir: string, providerId: string): Map<string, ProviderModelCooldown[]>;
-export declare function providerWrite<T>(agentDir: string, run: (db: DatabaseSync) => T): T;
-export declare function providerRevision(agentDir: string): number;

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

@@ -1,19 +0,0 @@
-import { prepared as cachedStatement } from '../sqlite-statements.js';
-import { openScopedStore, withScopedWrite } from './db.js';
-import { providerStore } from './paths.js';
-function map(row) { return { providerId: row.provider_id, id: row.id, label: row.label, labelKey: row.label_key, position: row.position, lastAttemptAt: row.last_attempt_at, lastRateLimitedAt: row.last_rate_limited_at, rateLimitedUntil: row.rate_limited_until, ...(row.auth_failure ? { authFailure: row.auth_failure } : {}) }; }
-const ROW_COLUMNS = 'provider_id,id,label,label_key,position,last_attempt_at,last_rate_limited_at,rate_limited_until,auth_failure';
-export function providerRows(agentDir, providerId) { const db = openScopedStore(providerStore(agentDir)); return db.prepare(`SELECT ${ROW_COLUMNS} FROM managed_accounts WHERE provider_id=? ORDER BY position`).all(providerId).map(map); }
-export function providerRowByReference(db, providerId, ref) { const needle = ref.trim().toLowerCase(); const position = Number.parseInt(needle, 10); const row = (Number.isFinite(position) && String(position) === needle && position >= 1 ? db.prepare(`SELECT ${ROW_COLUMNS} FROM managed_accounts WHERE provider_id=? AND position=?`).get(providerId, position - 1) : db.prepare(`SELECT ${ROW_COLUMNS} FROM managed_accounts WHERE provider_id=? AND label_key=?`).get(providerId, needle)); return row ? map(row) : undefined; }
-export function providerModelCooldowns(db, providerId) {
-    const out = new Map();
-    for (const row of cachedStatement(db, 'SELECT account_id,family,rate_limited_until,last_rate_limited_at FROM managed_account_model_cooldowns WHERE provider_id=? ORDER BY family').all(providerId)) {
-        const list = out.get(row.account_id) ?? [];
-        list.push({ family: row.family, rateLimitedUntil: row.rate_limited_until, lastRateLimitedAt: row.last_rate_limited_at });
-        out.set(row.account_id, list);
-    }
-    return out;
-}
-export function providerModelCooldownsFor(agentDir, providerId) { return providerModelCooldowns(openScopedStore(providerStore(agentDir)), providerId); }
-export function providerWrite(agentDir, run) { return withScopedWrite(providerStore(agentDir), (db) => { const value = run(db); cachedStatement(db, 'UPDATE provider_revision SET revision=revision+1 WHERE singleton=1').run(); return value; }); }
-export function providerRevision(agentDir) { const db = openScopedStore(providerStore(agentDir)); return cachedStatement(db, 'SELECT revision FROM provider_revision WHERE singleton=1').get().revision; }

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

@@ -1,10 +0,0 @@
-import type { DatabaseSync } from 'node:sqlite';
-export declare const SCOPED_SCHEMA_VERSION = 5;
-export declare const PROVIDER_SCHEMA_VERSION = 1;
-/** `profiles.environment_id` (null = the machine environment) is additive to version 5: a store written before it gains the
- *  column on open (`upgradeScopedStore`), and an older generation sharing the store names its columns and never reads it, so
- *  the version stays 5 and a runtime rollback keeps opening the store. */
-export declare const PROFILE_ENVIRONMENT_COLUMN = "environment_id";
-/** 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

@@ -1,47 +0,0 @@
-import { prepared as cachedStatement } from '../sqlite-statements.js';
-export const SCOPED_SCHEMA_VERSION = 5;
-export const PROVIDER_SCHEMA_VERSION = 1;
-/** `profiles.environment_id` (null = the machine environment) is additive to version 5: a store written before it gains the
- *  column on open (`upgradeScopedStore`), and an older generation sharing the store names its columns and never reads it, so
- *  the version stays 5 and a runtime rollback keeps opening the store. */
-export const PROFILE_ENVIRONMENT_COLUMN = 'environment_id';
-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)), environment_id TEXT);
-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

@@ -1,28 +0,0 @@
-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

@@ -1,104 +0,0 @@
-import { prepared as cachedStatement } from '../sqlite-statements.js';
-import { createHash } from 'node:crypto';
-import { openScopedStore, withScopedWrite } from './db.js';
-/**
- * The owner row ties a store to the thing it belongs to. For user and profile
- * owners the recorded root is the guard: those rows share one store, and a row
- * whose root differs belongs to something else. A project store is different —
- * it lives inside the root that opens it (`<root>/operations.db`), so the
- * location is the identity and the recorded root is only a note of where the
- * directory last was. When the directory is moved or renamed the note goes
- * stale; the owner is still the same project, so a write rebinds the note and a
- * read accepts it. Kind and profile still have to match, so a user or profile
- * store is never accepted as a project owner.
- */
-function ensureOwner(db, owner, access) {
-    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 || (owner.profileId ?? null) !== row.profile_id) {
-        throw new Error(`scoped SQL owner does not match its root: ${owner.key}`);
-    }
-    if (row.root === owner.root)
-        return;
-    // A profile row is keyed by its id, checked above; its recorded root is a note of where the folder was. A profile
-    // folder that moved (`<app>/memory/profiles/<id>` → `<app>/profiles/<id>`) is rebound by the first write.
-    const profileMoved = owner.kind === 'profile' && owner.profileId !== undefined;
-    if (!profileMoved && (owner.kind !== 'project' || owner.store.kind !== 'project' || owner.store.root !== owner.root)) {
-        throw new Error(`scoped SQL owner does not match its root: ${owner.key}`);
-    }
-    if (access === 'write')
-        cachedStatement(db, 'UPDATE scope_owners SET root = ? WHERE owner_key = ?').run(owner.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, 'read');
-    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, 'write');
-        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, 'write');
-        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, 'write');
-        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, 'read');
-    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, 'write');
-        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/sqlite-statements.d.ts

@@ -1,4 +0,0 @@
-import type { DatabaseSync, StatementSync } from 'node:sqlite';
-export declare function prepared(db: DatabaseSync, sql: string): StatementSync;
-/** Explicitly release compiled statements before closing or migrating a connection. */
-export declare function forgetPrepared(db: DatabaseSync): void;

package/dist/core/sqlite-statements.js

@@ -1,17 +0,0 @@
-/** Statements belong to a connection, not a database path. Cache only fixed SQL:
- * generated IN lists and schema-dependent SQL remain uncached at their call sites.
- */
-const statements = new WeakMap();
-export function prepared(db, sql) {
-    let byDb = statements.get(db);
-    if (!byDb)
-        statements.set(db, byDb = new Map());
-    let statement = byDb.get(sql);
-    if (!statement)
-        byDb.set(sql, statement = db.prepare(sql));
-    return statement;
-}
-/** Explicitly release compiled statements before closing or migrating a connection. */
-export function forgetPrepared(db) {
-    statements.delete(db);
-}