@north-light/crouter 0.3.312 → 0.3.313

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

@@ -0,0 +1,7 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { ScopedStore } from './paths.js';
+export declare function scopedStoreExists(store: ScopedStore): boolean;
+export declare function openScopedStore(store: ScopedStore): DatabaseSync;
+export declare function createScopedStore(store: ScopedStore, create: (db: DatabaseSync) => void): void;
+export declare function withScopedWrite<T>(store: ScopedStore, run: (db: DatabaseSync) => T): T;
+export declare function closeScopedStores(): void;

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

@@ -0,0 +1,92 @@
+import { DatabaseSync } from 'node:sqlite';
+import { chmodSync, existsSync, mkdirSync, statSync, writeFileSync } from 'node:fs';
+import { SCOPED_SCHEMA_VERSION } from './schema.js';
+const handles = new Map();
+function version(db) {
+    return Number(db.prepare('PRAGMA user_version').get().user_version);
+}
+function secure(path) {
+    if (existsSync(path))
+        chmodSync(path, 0o600);
+    for (const suffix of ['-wal', '-shm'])
+        if (existsSync(`${path}${suffix}`))
+            chmodSync(`${path}${suffix}`, 0o600);
+}
+export function scopedStoreExists(store) {
+    return existsSync(store.path);
+}
+export function openScopedStore(store) {
+    const cached = handles.get(store.path);
+    if (cached !== undefined)
+        return cached;
+    if (!existsSync(store.path))
+        throw new Error(`scoped SQL store is not initialized: ${store.path}; crtr was updated and \`crtr sys daemon restart\` converts local state`);
+    const db = new DatabaseSync(store.path);
+    db.exec('PRAGMA busy_timeout = 5000; PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON;');
+    const found = version(db);
+    if (found === 0) {
+        db.close();
+        throw new Error(`scoped SQL store is uninitialized: ${store.path}; crtr was updated and \`crtr sys daemon restart\` converts local state`);
+    }
+    if (found > SCOPED_SCHEMA_VERSION) {
+        db.close();
+        throw new Error(`scoped SQL store ${store.path} uses unsupported schema version ${found}`);
+    }
+    if (found !== SCOPED_SCHEMA_VERSION) {
+        db.close();
+        throw new Error(`scoped SQL store ${store.path} requires an explicit conversion`);
+    }
+    secure(store.path);
+    handles.set(store.path, db);
+    return db;
+}
+export function createScopedStore(store, create) {
+    if (existsSync(store.path))
+        throw new Error(`scoped SQL store already exists: ${store.path}`);
+    mkdirSync(store.root, { recursive: true, mode: 0o700 });
+    if (!statSync(store.root).isDirectory())
+        throw new Error(`scoped SQL root is not a directory: ${store.root}`);
+    chmodSync(store.root, 0o700);
+    writeFileSync(store.path, '', { mode: 0o600 });
+    const db = new DatabaseSync(store.path);
+    try {
+        db.exec('PRAGMA busy_timeout = 5000; PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; BEGIN IMMEDIATE;');
+        create(db);
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { }
+        throw error;
+    }
+    finally {
+        secure(store.path);
+        db.close();
+    }
+}
+export function withScopedWrite(store, run) {
+    const db = openScopedStore(store);
+    if (db.isTransaction)
+        return run(db);
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        const value = run(db);
+        db.exec('COMMIT');
+        secure(store.path);
+        return value;
+    }
+    catch (error) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { }
+        throw error;
+    }
+}
+export function closeScopedStores() {
+    for (const db of handles.values())
+        db.close();
+    handles.clear();
+}

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

@@ -0,0 +1,11 @@
+export declare function initializeFreshScopedStore(input: {
+    kind: 'user' | 'project' | 'provider';
+    root: string;
+}): void;
+/** Conversion is intentionally explicit. Deployment coordination must prove all legacy writers at these shared roots are stopped before calling it. */
+export declare function convertLegacyScopedStore(input: {
+    kind: 'user' | 'project' | 'provider';
+    root: string;
+}): void;
+/** Converts legacy provider pools only after the activation owner has stopped every writer sharing this agent directory. */
+export declare function convertLegacyProviderStore(agentDir: string): Promise<void>;

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

@@ -0,0 +1,198 @@
+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 { createScopedStore, scopedStoreExists } from './db.js';
+import { providerStore, projectStore, userStore } from './paths.js';
+import { createScopedSchema } from './schema.js';
+function writeOwnerRoot(db, key, root) { db.prepare('UPDATE scope_owners SET root=? WHERE owner_key=?').run(root, key); }
+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'); mkdirSync(target, { recursive: true, mode: 0o700 }); 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);
+        mkdirSync(dirname(destination), { recursive: true, mode: 0o700 });
+        copyFileSync(path, destination);
+        chmodSync(destination, 0o600);
+    } }
+const PROFILE_ID_SHAPE = /^[a-z0-9]+(?:-[a-z0-9]+)*-[0-9a-f]{8}$/;
+function userLegacyPaths(root) { const out = [join(root, CONFIG_FILE), join(root, STATE_FILE), join(root, 'profile-defaults.json')]; 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))
+            out.push(join(profiles, entry.name, 'profile.json'), join(profiles, entry.name, CONFIG_FILE), join(profiles, entry.name, STATE_FILE)); return out; }
+function providerLegacyPaths(agentDir) { return [join(agentDir, 'anthropic-subscriptions.json'), join(agentDir, 'openai-codex-subscriptions.json'), join(agentDir, 'provider-rotation.json')]; }
+function withLegacyProjectStateLock(root, run) {
+    const path = join(root, STATE_FILE);
+    const release = lockfile.lockSync(path, { realpath: false, retries: 0, stale: 30_000, update: 10_000 });
+    try {
+        return run();
+    }
+    finally {
+        release();
+    }
+}
+export function initializeFreshScopedStore(input) {
+    const store = input.kind === 'user' ? userStore(input.root) : input.kind === 'project' ? projectStore(input.root) : providerStore(input.root);
+    if (scopedStoreExists(store))
+        return;
+    const legacy = input.kind === 'user' ? userLegacyPaths(store.root) : input.kind === 'project' ? [join(store.root, STATE_FILE)] : providerLegacyPaths(store.root);
+    const legacyPath = legacy.find(existsSync);
+    if (legacyPath !== undefined)
+        throw new Error(`legacy scoped state exists at ${legacyPath}; crtr was updated and \`crtr sys daemon restart\` converts local state`);
+    createScopedStore(store, (db) => { createScopedSchema(db, input.kind); if (input.kind !== 'provider')
+        writeOwnerRoot(db, input.kind === 'user' ? 'user' : 'project', store.root); });
+}
+/** 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 (scopedStoreExists(store))
+        return;
+    if (input.kind === 'provider')
+        throw new Error('provider conversion requires convertLegacyProviderStore() under coordinated shared-agent-dir activation');
+    const paths = input.kind === 'user' ? userLegacyPaths(store.root) : [join(store.root, STATE_FILE)];
+    const convert = () => {
+        if (scopedStoreExists(store))
+            return;
+        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 (existsLegacy(paths))
+            preserve(store.root, paths);
+    };
+    if (input.kind === 'project')
+        withLegacyProjectStateLock(store.root, convert);
+    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 = providerLegacyPaths(store.root);
+    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]);
+        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 = db.prepare('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)
+                db.prepare('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}`); db.prepare('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; db.prepare('INSERT INTO scope_bookkeeping(owner_key,last_self_check,active_canvas) VALUES(?,?,?)').run(owner, state.last_self_check ?? null, state.activeCanvas ?? null); 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, name, value.last_updated ?? null); const plugins = db.prepare('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}`);
+            db.prepare('INSERT INTO profiles(id,name,created_at,last_used_at,paused_at,home,default_kind,metadata_json) VALUES(?,?,?,?,?,?,?,?)').run(id, manifest.name, manifest.created_at, manifest.last_used_at ?? null, manifest.paused_at ?? null, manifest.home ?? null, manifest.default_kind ?? null, JSON.stringify(manifest.metadata ?? {}));
+            db.prepare('INSERT INTO scope_owners(owner_key,kind,root,profile_id) VALUES(?,?,?,?)').run(`profile:${id}`, 'profile', profileRoot, id);
+            const project = db.prepare('INSERT INTO profile_projects(profile_id,path,position,memory) VALUES(?,?,?,?)');
+            manifest.projects.forEach((p, position) => project.run(id, p.path, position, 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 = db.prepare('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/paths.d.ts

@@ -0,0 +1,9 @@
+export type ScopedStore = {
+    path: string;
+    root: string;
+    kind: 'user' | 'project' | 'provider';
+};
+export declare function canonicalRoot(root: string): string;
+export declare function userStore(root: string): ScopedStore;
+export declare function projectStore(root: string): ScopedStore;
+export declare function providerStore(agentDir: string): ScopedStore;

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

@@ -0,0 +1,27 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+export function canonicalRoot(root) {
+    const absolute = resolve(root);
+    let existing = absolute;
+    const missing = [];
+    while (!existsSync(existing)) {
+        const parent = dirname(existing);
+        if (parent === existing)
+            return absolute;
+        missing.unshift(basename(existing));
+        existing = parent;
+    }
+    return resolve(realpathSync(existing), ...missing);
+}
+export function userStore(root) {
+    const canonical = canonicalRoot(root);
+    return { path: join(canonical, 'operations.db'), root: canonical, kind: 'user' };
+}
+export function projectStore(root) {
+    const canonical = canonicalRoot(root);
+    return { path: join(canonical, 'operations.db'), root: canonical, kind: 'project' };
+}
+export function providerStore(agentDir) {
+    const canonical = canonicalRoot(agentDir);
+    return { path: join(canonical, 'crouter-operations.db'), root: canonical, kind: 'provider' };
+}

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

@@ -0,0 +1,12 @@
+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;
+export declare function insertStoredProfile(root: string, profile: StoredProfile, profileRoot: string): 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 readStoredDefaults(root: string): Record<string, string>;
+export declare function mutateStoredDefaults(root: string, mutate: (current: Record<string, string>) => Record<string, string>): Record<string, string>;

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

@@ -0,0 +1,62 @@
+import { canonicalRoot, userStore } from './paths.js';
+import { openScopedStore, withScopedWrite } from './db.js';
+function store(root) { return userStore(root); }
+function rowToProfile(row, projects) {
+    return { profileId: row.id, manifest: { schema_version: 1, name: row.name, projects, home: row.home, paused_at: row.paused_at, ...(row.default_kind === null ? {} : { default_kind: row.default_kind }), ...(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 = db.prepare('SELECT id, name, created_at, last_used_at, paused_at, home, default_kind, metadata_json FROM profiles WHERE id=?').get(id);
+    if (!row)
+        return null;
+    const projects = db.prepare('SELECT path, memory 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 = db.prepare('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); }
+export function insertStoredProfile(root, profile, profileRoot) {
+    withScopedWrite(store(root), (db) => {
+        db.prepare('INSERT INTO profiles(id,name,created_at,last_used_at,paused_at,home,default_kind,metadata_json) VALUES(?,?,?,?,?,?,?,?)').run(profile.profileId, profile.manifest.name, profile.manifest.created_at, profile.manifest.last_used_at, profile.manifest.paused_at, profile.manifest.home, profile.manifest.default_kind ?? null, JSON.stringify(profile.manifest.metadata ?? {}));
+        db.prepare('INSERT INTO scope_owners(owner_key,kind,root,profile_id) VALUES(?,?,?,?)').run(`profile:${profile.profileId}`, 'profile', canonicalRoot(profileRoot), profile.profileId);
+        const insert = db.prepare('INSERT INTO profile_projects(profile_id,path,position,memory) VALUES(?,?,?,?)');
+        profile.manifest.projects.forEach((project, position) => insert.run(profile.profileId, project.path, position, project.memory));
+    });
+}
+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);
+        db.prepare('UPDATE profiles SET name=?, last_used_at=?, paused_at=?, home=?, default_kind=?, metadata_json=? WHERE id=?').run(next.name, next.last_used_at, next.paused_at, next.home, next.default_kind ?? null, JSON.stringify(next.metadata ?? {}), id);
+        db.prepare('DELETE FROM profile_projects WHERE profile_id=?').run(id);
+        const insert = db.prepare('INSERT INTO profile_projects(profile_id,path,position,memory) VALUES(?,?,?,?)');
+        next.projects.forEach((project, position) => insert.run(id, project.path, position, project.memory));
+        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}`;
+        db.prepare('DELETE FROM scope_settings WHERE owner_key=?').run(owner);
+        db.prepare('DELETE FROM scope_bookkeeping WHERE owner_key=?').run(owner);
+        db.prepare('DELETE FROM scope_marketplaces WHERE owner_key=?').run(owner);
+        db.prepare('DELETE FROM scope_plugins WHERE owner_key=?').run(owner);
+        db.prepare('DELETE FROM scope_owners WHERE owner_key=?').run(owner);
+        db.prepare('DELETE FROM profiles WHERE id=?').run(id);
+        return true;
+    });
+}
+export function readStoredDefaults(root) {
+    const db = openScopedStore(store(root));
+    return Object.fromEntries(db.prepare('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(db.prepare('SELECT directory,profile_id FROM profile_defaults').all().map((row) => [row.directory, row.profile_id])); const next = mutate(current); db.prepare('DELETE FROM profile_defaults').run(); const insert = db.prepare('INSERT INTO profile_defaults(directory,profile_id) VALUES(?,?)'); for (const [directory, id] of Object.entries(next))
+        insert.run(directory, id); return next; });
+}

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

@@ -0,0 +1,16 @@
+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';
+};
+export declare function providerRows(agentDir: string, providerId: string): ProviderRow[];
+export declare function providerRowByReference(db: DatabaseSync, providerId: string, ref: string): ProviderRow | undefined;
+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

@@ -0,0 +1,8 @@
+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 providerWrite(agentDir, run) { return withScopedWrite(providerStore(agentDir), (db) => { const value = run(db); db.prepare('UPDATE provider_revision SET revision=revision+1 WHERE singleton=1').run(); return value; }); }
+export function providerRevision(agentDir) { const db = openScopedStore(providerStore(agentDir)); return db.prepare('SELECT revision FROM provider_revision WHERE singleton=1').get().revision; }

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

@@ -0,0 +1,3 @@
+import type { DatabaseSync } from 'node:sqlite';
+export declare const SCOPED_SCHEMA_VERSION = 1;
+export declare function createScopedSchema(db: DatabaseSync, kind: 'user' | 'project' | 'provider'): void;

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

@@ -0,0 +1,26 @@
+export const SCOPED_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, home TEXT, default_kind TEXT, metadata_json TEXT NOT NULL CHECK(json_valid(metadata_json)));
+CREATE TABLE profile_projects (profile_id TEXT NOT NULL REFERENCES profiles(id) ON DELETE CASCADE, path TEXT NOT NULL, position INTEGER NOT NULL, memory TEXT NOT NULL CHECK(memory IN ('none','name','preview','content')), PRIMARY KEY(profile_id,path), UNIQUE(profile_id,position));
+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));`;
+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);`;
+export function createScopedSchema(db, kind) {
+    db.exec(kind === 'provider' ? PROVIDER_SCHEMA : SCOPE_SCHEMA);
+    if (kind !== 'provider') {
+        const ownerKey = kind === 'user' ? 'user' : 'project';
+        db.prepare('INSERT INTO scope_owners(owner_key, kind, root, profile_id) VALUES (?, ?, ?, NULL)').run(ownerKey, kind, '');
+    }
+    else {
+        db.prepare('INSERT INTO provider_revision(singleton, revision) VALUES (1, 0)').run();
+    }
+    db.exec(`PRAGMA user_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,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);
+    });
+}