@north-light/api 0.3.561 → 0.3.563

package/dist/types.d.ts

@@ -405,6 +405,18 @@ export interface ScopeConfig {
     /** The money ledger. `take_pct` (0-100, default 0) is Northlight's take on each priced model or tool charge; at 0 no take rows are written. */
     ledger?: {
         take_pct?: number;
+        /** USD per GB-hour of Blaxel sandbox awake time; the `ledger-sandbox` lane writes no rows while it is unset. */
+        sandbox_usd_per_gb_hour?: number;
+        /** Seconds a sandbox stays awake after its broker goes idle or exits (default 30). */
+        sandbox_standby_s?: number;
+        /** USD per GB-month of R2 storage; the `ledger-storage` lane writes no `r2` rows while it is unset. */
+        storage_usd_per_gb_month?: number;
+        /** USD per GB-month of Blaxel sandbox disk; the `ledger-storage` lane writes no `blaxel` rows while it is unset. */
+        sandbox_disk_usd_per_gb_month?: number;
+        /** USD of sandbox and storage a billing account uses free each UTC month (default 50); `billed_usd` on those rows is the part above it. */
+        infra_free_usd_per_month?: number;
+        /** The `ledger-r2` lane moves closed months into the blob store only while this is true (off until 5b is accepted). */
+        r2_move?: boolean;
     };
     /** Conversation store configuration for the daemon. */
     store?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/api",
-  "version": "0.3.561",
+  "version": "0.3.563",
   "description": "Typed crtrd /v1 API contract — DTOs, route builders, the error contract, the CrtrClient, and the command-plugin manifest format. Zero runtime dependencies.",
   "type": "module",
   "main": "./dist/api/index.js",

package/dist/core/canvas/legacy-person.d.ts

@@ -1,4 +0,0 @@
-/** The person principal every install carried before it minted its own: read only by the one-shot that retires it and by the legacy SQLite/layout importers. Pure so CLI-reachable modules can import it. */
-export declare const LEGACY_LOCAL_PERSON = "user:local";
-/** The id of the local terminal grant an install carried before its grant became `terminal:<install id>`; nodes, tokens, crons and queued births may still reference it. */
-export declare const LEGACY_LOCAL_TERMINAL_GRANT = "local:terminal";

package/dist/core/canvas/legacy-person.js

@@ -1,4 +0,0 @@
-/** The person principal every install carried before it minted its own: read only by the one-shot that retires it and by the legacy SQLite/layout importers. Pure so CLI-reachable modules can import it. */
-export const LEGACY_LOCAL_PERSON = 'user:local';
-/** The id of the local terminal grant an install carried before its grant became `terminal:<install id>`; nodes, tokens, crons and queued births may still reference it. */
-export const LEGACY_LOCAL_TERMINAL_GRANT = 'local:terminal';

package/dist/core/locked-file.d.ts

@@ -1,27 +0,0 @@
-export type LockResult<T> = {
-    result: T;
-    next?: string;
-};
-/** Throws if this lock was compromised (stolen/expired) since acquisition. Callers that write
- *  from INSIDE the critical section must call it immediately before that write, because the
- *  post-`fn` check cannot un-write a file the callback already replaced. */
-export type LockHeldGuard = () => void;
-export type LockedFilePublish = (next: string) => void;
-export interface LockedFileBackend {
-    withLockAsync<T>(fn: (current: string | undefined, assertLockHeld: LockHeldGuard, publish: LockedFilePublish) => Promise<LockResult<T>>): Promise<T>;
-    /** The current whole-file contents, or undefined when the file does not exist yet.
-     *  Lock-free: every writer replaces the file by atomic rename. */
-    readUnlocked(): string | undefined;
-}
-/** A 0600 JSON file guarded by a cross-process `proper-lockfile` lock on its own path. */
-export declare class LockedJsonFile implements LockedFileBackend {
-    private readonly path;
-    private readonly durable;
-    private readonly initialContent;
-    constructor(path: string, durable?: boolean, initialContent?: string);
-    readUnlocked(): string | undefined;
-    private ensureFile;
-    /** Acquire the lock without blocking the event loop, keeping every read-modify-write
-     *  callback on the same asynchronous path. */
-    withLockAsync<T>(fn: (current: string | undefined, assertLockHeld: LockHeldGuard, publish: LockedFilePublish) => Promise<LockResult<T>>): Promise<T>;
-}

package/dist/core/locked-file.js

@@ -1,121 +0,0 @@
-// locked-file.ts — crouter's cross-process locked read/modify/write primitive for the
-// small JSON state files the runtime co-owns with pi: pi's own `auth.json` (api keys and
-// non-managed OAuth credentials) and crouter's per-provider subscription pool files, which
-// hold every managed account's own credential.
-//
-// The lock is `proper-lockfile` on the target path, so a crouter process and a pi process
-// contending for `auth.json` still exclude each other: same library, same lock path, and
-// same `realpath: false` option. Every callback runs asynchronously and returns
-// `{ result, next }`; `next === undefined` means "no write". Every write lands by atomic
-// tmp+rename (pool callers do their own, inside the callback), so a whole snapshot is the
-// only thing on disk and READS need no lock at all -- `readUnlocked` serves them. That
-// matters: pi asks its CredentialStore for every registered provider (~75) whenever it
-// builds a model runtime, and routing those through the lock made each boot serialize
-// behind seconds of lock acquisition backoff.
-import { chmodSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync, closeSync } from 'node:fs';
-import { dirname } from 'node:path';
-import lockfile from 'proper-lockfile';
-import { publishFileExclusive } from './fs-utils.js';
-const WRITE_OPTIONS = { encoding: 'utf-8', mode: 0o600 };
-// proper-lockfile decides a held lock is abandoned when its lockdir mtime is older than
-// the acquirer's `stale`, and refreshes the mtime on the holder's `update` timer. The holder
-// refreshes well inside the staleness threshold so long-running callbacks remain protected.
-const LOCK_STALE_MS = 30_000;
-const LOCK_UPDATE_MS = 5_000;
-/** A 0600 JSON file guarded by a cross-process `proper-lockfile` lock on its own path. */
-export class LockedJsonFile {
-    path;
-    durable;
-    initialContent;
-    constructor(path, durable = false, initialContent = '{}') {
-        this.path = path;
-        this.durable = durable;
-        this.initialContent = initialContent;
-    }
-    readUnlocked() {
-        return existsSync(this.path) ? readFileSync(this.path, 'utf-8') : undefined;
-    }
-    ensureFile() {
-        const dir = dirname(this.path);
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true, mode: 0o700 });
-        if (!existsSync(this.path)) {
-            // Published whole and exclusively: another process may be creating it too, and a
-            // reader (or a lost write) must never see the empty file a plain create leaves.
-            publishFileExclusive(this.path, this.initialContent, 0o600);
-            chmodSync(this.path, 0o600);
-        }
-    }
-    /** Acquire the lock without blocking the event loop, keeping every read-modify-write
-     *  callback on the same asynchronous path. */
-    async withLockAsync(fn) {
-        this.ensureFile();
-        let release;
-        let compromised;
-        const throwIfCompromised = () => {
-            if (compromised)
-                throw compromised;
-        };
-        try {
-            release = await lockfile.lock(this.path, {
-                // A different realpath setting would derive a DIFFERENT lock path for a symlinked
-                // auth.json and silently stop excluding other writers.
-                realpath: false,
-                retries: { retries: 10, factor: 2, minTimeout: 100, maxTimeout: 10_000, randomize: true },
-                stale: LOCK_STALE_MS,
-                // Refresh the lockdir mtime well inside `stale` so long-running callbacks remain protected.
-                update: LOCK_UPDATE_MS,
-                onCompromised: (err) => {
-                    compromised = err;
-                },
-            });
-            throwIfCompromised();
-            const current = existsSync(this.path) ? readFileSync(this.path, 'utf-8') : undefined;
-            let published = false;
-            const publish = (next) => {
-                if (published)
-                    throw new Error(`locked file was published twice: ${this.path}`);
-                throwIfCompromised();
-                const tmp = `${this.path}.${process.pid}.${Date.now()}.tmp`;
-                writeFileSync(tmp, next, WRITE_OPTIONS);
-                chmodSync(tmp, 0o600);
-                if (this.durable) {
-                    const fd = openSync(tmp, 'r');
-                    try {
-                        fsyncSync(fd);
-                    }
-                    finally {
-                        closeSync(fd);
-                    }
-                }
-                renameSync(tmp, this.path);
-                if (this.durable) {
-                    const fd = openSync(dirname(this.path), 'r');
-                    try {
-                        fsyncSync(fd);
-                    }
-                    finally {
-                        closeSync(fd);
-                    }
-                }
-                published = true;
-            };
-            const { result, next } = await fn(current, throwIfCompromised, publish);
-            throwIfCompromised();
-            if (next !== undefined)
-                publish(next);
-            throwIfCompromised();
-            return result;
-        }
-        finally {
-            if (release) {
-                try {
-                    await release();
-                }
-                catch {
-                    // A compromised lock's release throws; the compromise itself already surfaced.
-                }
-            }
-        }
-    }
-}

package/dist/core/profiles/env-store.d.ts

@@ -1,22 +0,0 @@
-export declare function isReservedEnvName(name: string): boolean;
-/** Every stored variable NAME for a profile, sorted. Never returns values. */
-export declare function listProfileEnvNames(profileId: string): string[];
-/** Set one variable, replacing any prior value under the same name. Holds the
- *  same per-profile lock manifest mutations use (`withProfileManifestLock`),
- *  so a concurrent `profile delete` can never race a write into an
- *  about-to-vanish profile dir — whichever runs first wins the lock, and the
- *  loser either sees `not_found` (delete-then-set) or removes the file right
- *  back out from under a just-written value (set-then-delete, via
- *  `deleteProfile`'s recursive rm of the whole profile root). Returns whether
- *  the name was newly added (`true`) or replaced an existing value (`false`). */
-export declare function setProfileEnvVar(profileId: string, name: string, value: string): boolean;
-/** Remove one variable. Returns whether it was present. */
-export declare function removeProfileEnvVar(profileId: string, name: string): boolean;
-/** Every stored `{name: value}` for a profile — the ONLY function that
- *  returns raw values, called exclusively by `buildBrokerEnv`
- *  (`core/runtime/spawn-env.ts`) to inject them directly into a launched
- *  broker's env. Never throws: a stale/invalid/deleted profile id is a
- *  hot-path no-op (mirrors `readRawProfileConfig` in `core/config.ts`),
- *  because broker-env resolution must never fail a launch over a bad profile
- *  id. */
-export declare function readProfileEnvVars(profileId: string | null): Record<string, string>;

package/dist/core/profiles/env-store.js

@@ -1,166 +0,0 @@
-// The profile-owned env store: `<runtime>/secrets/env/<app>/<profileId>` — a 0600
-// map of env-var name -> value a profile owns explicitly. `buildBrokerEnv`
-// (`core/runtime/spawn-env.ts`) reads it straight off disk and injects the
-// values directly into every broker launched under that profile, independent
-// of the daemon's own ambient `process.env` or any `.envrc`/`.env` a node's
-// cwd might carry. Setting a value here IS the consent to cross the spawn
-// boundary — no matching `spawnEnv.allow` entry is needed, because these
-// values never pass through the host-env allowlist in the first place; they
-// are a separate, always-injected source. Never surface a stored VALUE
-// outside this file's own readers — `listProfileEnvNames` returns names only,
-// and no caller should log or echo what `readProfileEnvVars` returns.
-import { existsSync, readFileSync, renameSync, writeFileSync, chmodSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { profileSpace } from '../layout.js';
-import { loadExactProfileManifest, withProfileManifestLock } from './manifest.js';
-import { ensureDir } from '../fs-utils.js';
-import { notFound, usage } from '../errors.js';
-/** crtr's own identity/routing env names — reserved so a stored profile value
- *  can never redirect a broker to a different canvas home/db/socket dir or
- *  masquerade as its own process identity. `HOME` is reserved alongside the
- *  `CRTR_*` family because crtr has no independent authoritative scope root
- *  yet; every path in `core/canvas/paths.ts` ultimately derives from it.
- *  Enforced at write (`setProfileEnvVar` throws below) AND defensively at
- *  read (`readStoreUnlocked`, which every reader — list/set/remove/inject —
- *  goes through), so even a reserved name that reached disk some other way
- *  (hand-edited file, a pre-reservation write) is uniformly invisible rather
- *  than trusted.
- *
- *  The deployment-wide feedback names are the only `CRTR_*` values stored
- *  anywhere; they live in their own store (`profiles/app-env-store.ts`). */
-const RESERVED_ENV_PREFIX = 'CRTR_';
-const RESERVED_ENV_EXACT_NAMES = new Set(['HOME']);
-export function isReservedEnvName(name) {
-    return name.startsWith(RESERVED_ENV_PREFIX) || RESERVED_ENV_EXACT_NAMES.has(name);
-}
-/** NUL is the one byte no OS accepts in an env value — Node's own `spawn`
- *  rejects it synchronously and echoes the full value in the thrown error, so
- *  it must never reach storage or a spawn call. */
-function hasNulByte(value) {
-    return value.includes('\0');
-}
-function envPath(profileId) {
-    const profile = loadExactProfileManifest(profileId);
-    return profileSpace(profile.manifest.grantee ?? 'app:terminal', profileId).env;
-}
-/** Reads env.json into a null-prototype, sanitized own-property map.
- *  Null-prototype so a stored name like `__proto__` is a plain own data
- *  property instead of silently colliding with the inherited accessor on an
- *  ordinary object (which would make `in`/assignment lie about what's
- *  actually stored — `created`/`removed` would misreport, and the value
- *  would never actually persist). Sanitized — dropping any non-string,
- *  NUL-containing, or reserved-name entry — because this file may have been
- *  hand-edited or written by a version that predates these guards, and every
- *  reader (list/set/remove/inject) shares this one function, so a bad
- *  on-disk entry is uniformly invisible instead of leaking into one path but
- *  not another. Never throws: a corrupt file degrades to empty, matching the
- *  prior behavior. */
-function readStoreUnlocked(profileId) {
-    const p = envPath(profileId);
-    const vars = Object.create(null);
-    if (!existsSync(p))
-        return { vars };
-    try {
-        const parsed = JSON.parse(readFileSync(p, 'utf8'));
-        for (const [name, value] of Object.entries(parsed.vars ?? {})) {
-            if (typeof value !== 'string')
-                continue;
-            if (hasNulByte(value))
-                continue;
-            if (isReservedEnvName(name))
-                continue;
-            vars[name] = value;
-        }
-    }
-    catch {
-        // Corrupt/unparseable file: degrade to whatever was sanitized so far
-        // (empty, since the loop above never ran).
-    }
-    return { vars };
-}
-/** Writes env.json directly (never via `fs-utils`' generic writers, which
- *  have no mode control) so the file is created 0600 from the first byte,
- *  then `chmodSync`s belt-and-suspenders in case it pre-existed with looser
- *  permissions — the same shape as `core/secrets.ts`. Atomic via tmp+rename. */
-function writeStoreAtomic(profileId, store) {
-    const p = envPath(profileId);
-    ensureDir(dirname(p));
-    const tmp = `${p}.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`;
-    writeFileSync(tmp, JSON.stringify(store, null, 2) + '\n', { mode: 0o600 });
-    chmodSync(tmp, 0o600);
-    renameSync(tmp, p);
-}
-function requireProfileExists(profileId) {
-    try {
-        loadExactProfileManifest(profileId);
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.startsWith('profile not found:'))
-            throw notFound(`profile not found: ${profileId}`, { received: profileId });
-        throw error;
-    }
-}
-/** Every stored variable NAME for a profile, sorted. Never returns values. */
-export function listProfileEnvNames(profileId) {
-    return Object.keys(readStoreUnlocked(profileId).vars).sort();
-}
-/** Set one variable, replacing any prior value under the same name. Holds the
- *  same per-profile lock manifest mutations use (`withProfileManifestLock`),
- *  so a concurrent `profile delete` can never race a write into an
- *  about-to-vanish profile dir — whichever runs first wins the lock, and the
- *  loser either sees `not_found` (delete-then-set) or removes the file right
- *  back out from under a just-written value (set-then-delete, via
- *  `deleteProfile`'s recursive rm of the whole profile root). Returns whether
- *  the name was newly added (`true`) or replaced an existing value (`false`). */
-export function setProfileEnvVar(profileId, name, value) {
-    if (isReservedEnvName(name)) {
-        throw usage(`env var name is reserved by crtr: ${name}`, {
-            received: name,
-            field: 'name',
-            next: 'crtr identity/routing names (CRTR_* and HOME) cannot be stored in a profile env store — a stored value under one of these names could redirect a broker to a different canvas home. Choose a different name.',
-        });
-    }
-    if (hasNulByte(value)) {
-        throw usage('env var value contains a NUL byte, which no OS accepts in an environment variable', {
-            field: 'value',
-            next: 'Remove NUL bytes from the piped value and retry.',
-        });
-    }
-    return withProfileManifestLock(profileId, () => {
-        requireProfileExists(profileId);
-        const store = readStoreUnlocked(profileId);
-        const created = !Object.hasOwn(store.vars, name);
-        store.vars[name] = value;
-        writeStoreAtomic(profileId, store);
-        return created;
-    });
-}
-/** Remove one variable. Returns whether it was present. */
-export function removeProfileEnvVar(profileId, name) {
-    return withProfileManifestLock(profileId, () => {
-        requireProfileExists(profileId);
-        const store = readStoreUnlocked(profileId);
-        if (!Object.hasOwn(store.vars, name))
-            return false;
-        delete store.vars[name];
-        writeStoreAtomic(profileId, store);
-        return true;
-    });
-}
-/** Every stored `{name: value}` for a profile — the ONLY function that
- *  returns raw values, called exclusively by `buildBrokerEnv`
- *  (`core/runtime/spawn-env.ts`) to inject them directly into a launched
- *  broker's env. Never throws: a stale/invalid/deleted profile id is a
- *  hot-path no-op (mirrors `readRawProfileConfig` in `core/config.ts`),
- *  because broker-env resolution must never fail a launch over a bad profile
- *  id. */
-export function readProfileEnvVars(profileId) {
-    if (profileId === null || profileId === '')
-        return {};
-    try {
-        return { ...readStoreUnlocked(profileId).vars };
-    }
-    catch {
-        return {};
-    }
-}

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

@@ -1,17 +0,0 @@
-import { DatabaseSync } from 'node:sqlite';
-import { type ScopedStore } from './paths.js';
-export declare const PROFILE_ID_SHAPE: RegExp;
-export declare function writeOwnerRoot(db: DatabaseSync, key: string, root: string): void;
-export declare function assertScopedStoreReady(store: ScopedStore): void;
-export declare function discardIncompleteScopedStore(store: ScopedStore): void;
-export declare function withProjectStateLock<T>(root: string, run: () => T): T;
-export declare function scopedStoreExists(store: ScopedStore): boolean;
-export declare function legacyScopedStorePaths(store: ScopedStore): string[];
-export declare function initializeFreshScopedStore(input: {
-    kind: 'user' | 'project' | 'provider';
-    root: string;
-}): void;
-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

@@ -1,261 +0,0 @@
-import { DatabaseSync } from 'node:sqlite';
-import { forgetPrepared } from '../sqlite-statements.js';
-import { chmodSync, existsSync, mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import lockfile from 'proper-lockfile';
-import { CONFIG_FILE, PROFILE_DIR, STATE_FILE } from '../../types.js';
-import { withExclusiveDirectoryLock } from '../exclusive-lock.js';
-import { syncDirectory, syncFile } from '../fs-utils.js';
-import { layoutNeedsMigration } from '../layout.js';
-import { providerStore, projectStore, userStore } from './paths.js';
-import { createScopedSchema, ensureProviderModelCooldowns, PROFILE_ENVIRONMENT_COLUMN, PROVIDER_SCHEMA_VERSION, SCOPED_SCHEMA_VERSION } from './schema.js';
-const handles = new Map();
-export const PROFILE_ID_SHAPE = /^[a-z0-9]+(?:-[a-z0-9]+)*-[0-9a-f]{8}$/;
-export function writeOwnerRoot(db, key, root) {
-    db.prepare('UPDATE scope_owners SET root=? WHERE owner_key=?').run(root, key);
-}
-function version(db) {
-    return Number(db.prepare('PRAGMA user_version').get().user_version);
-}
-function assertVersion(db, store) {
-    const found = version(db);
-    if (found === 0)
-        throw new Error(`scoped SQL store is uninitialized: ${store.path}; crtr was updated and \`crtr sys daemon restart\` converts local state`);
-    const expected = store.kind === 'provider' ? PROVIDER_SCHEMA_VERSION : SCOPED_SCHEMA_VERSION;
-    if (found > expected)
-        throw new Error(`scoped SQL store ${store.path} uses unsupported schema version ${found}`);
-    if (found !== expected)
-        throw new Error(`scoped SQL store ${store.path} requires an explicit conversion`);
-}
-function profilesHaveEnvironmentColumn(db) {
-    return db.prepare('PRAGMA table_info(profiles)').all().some(({ name }) => name === PROFILE_ENVIRONMENT_COLUMN);
-}
-function upgradeScopedStore(db, store) {
-    if (store.kind === 'provider') {
-        if (version(db) === PROVIDER_SCHEMA_VERSION) {
-            db.exec('PRAGMA busy_timeout = 5000');
-            ensureProviderModelCooldowns(db);
-        }
-        return;
-    }
-    if (version(db) > SCOPED_SCHEMA_VERSION)
-        return;
-    db.exec('PRAGMA busy_timeout = 5000');
-    if (version(db) === SCOPED_SCHEMA_VERSION && profilesHaveEnvironmentColumn(db))
-        return;
-    db.exec('BEGIN IMMEDIATE');
-    try {
-        if (version(db) === 1) {
-            const columns = db.prepare('PRAGMA table_info(profiles)').all();
-            if (!columns.some(({ name }) => name === 'grantee'))
-                db.exec('ALTER TABLE profiles ADD COLUMN grantee TEXT');
-            db.exec('PRAGMA user_version = 2');
-        }
-        if (version(db) === 2) {
-            const columns = db.prepare('PRAGMA table_info(profiles)').all();
-            if (columns.some(({ name }) => name === 'home'))
-                db.exec('ALTER TABLE profiles DROP COLUMN home');
-            db.exec('PRAGMA user_version = 3');
-        }
-        if (version(db) === 3) {
-            db.exec("ALTER TABLE profiles ADD COLUMN delivery_limits_json TEXT NOT NULL DEFAULT '{}' CHECK(json_valid(delivery_limits_json))");
-            db.exec('PRAGMA user_version = 4');
-        }
-        if (version(db) === 4) {
-            db.exec(`CREATE TABLE IF NOT EXISTS 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))`);
-            const columns = db.prepare('PRAGMA table_info(profile_projects)').all();
-            if (columns.some(({ name }) => name === 'memory')) {
-                db.exec(`INSERT INTO legacy_project_caps SELECT profile_id, path, memory FROM profile_projects WHERE memory != 'content';
-          ALTER TABLE profile_projects DROP COLUMN memory;`);
-            }
-            db.exec(`PRAGMA user_version = ${SCOPED_SCHEMA_VERSION}`);
-        }
-        if (version(db) === SCOPED_SCHEMA_VERSION && !profilesHaveEnvironmentColumn(db))
-            db.exec(`ALTER TABLE profiles ADD COLUMN ${PROFILE_ENVIRONMENT_COLUMN} TEXT`);
-        db.exec('COMMIT');
-    }
-    catch (error) {
-        db.exec('ROLLBACK');
-        throw error;
-    }
-}
-export function assertScopedStoreReady(store) {
-    const db = new DatabaseSync(store.path);
-    try {
-        upgradeScopedStore(db, store);
-        assertVersion(db, store);
-    }
-    finally {
-        db.close();
-    }
-}
-export function discardIncompleteScopedStore(store) {
-    if (!scopedStoreExists(store))
-        return;
-    const db = new DatabaseSync(store.path, { readOnly: true });
-    let found;
-    try {
-        found = version(db);
-    }
-    finally {
-        db.close();
-    }
-    if (found === 0)
-        for (const path of [store.path, `${store.path}-wal`, `${store.path}-shm`])
-            rmSync(path, { force: true });
-}
-export function withProjectStateLock(root, run) {
-    return withExclusiveDirectoryLock(join(root, '.init.lock'), () => {
-        const path = join(root, STATE_FILE);
-        const deadline = Date.now() + 5_000;
-        let pollMs = 10;
-        for (;;) {
-            let release;
-            try {
-                release = lockfile.lockSync(path, { realpath: false, retries: 0, stale: 30_000, update: 10_000 });
-            }
-            catch (error) {
-                if (error.code !== 'ELOCKED')
-                    throw error;
-                const remaining = deadline - Date.now();
-                if (remaining <= 0)
-                    throw new Error(`timed out waiting for project state conversion lock: ${path}`, { cause: error });
-                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.min(pollMs, remaining));
-                pollMs = Math.min(pollMs * 2, 250);
-                continue;
-            }
-            try {
-                return run();
-            }
-            finally {
-                release();
-            }
-        }
-    });
-}
-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 legacyScopedStorePaths(store) {
-    if (store.kind === 'project')
-        return [join(store.root, STATE_FILE)];
-    if (store.kind === 'provider')
-        return [join(store.root, 'anthropic-subscriptions.json'), join(store.root, 'openai-codex-subscriptions.json'), join(store.root, 'provider-rotation.json')];
-    const paths = [join(store.root, CONFIG_FILE), join(store.root, STATE_FILE), join(store.root, 'profile-defaults.json')];
-    const profiles = join(store.root, PROFILE_DIR);
-    if (existsSync(profiles))
-        for (const entry of readdirSync(profiles, { withFileTypes: true }))
-            if (entry.isDirectory() && PROFILE_ID_SHAPE.test(entry.name))
-                paths.push(join(profiles, entry.name, 'profile.json'), join(profiles, entry.name, CONFIG_FILE), join(profiles, entry.name, STATE_FILE));
-    return paths;
-}
-export function initializeFreshScopedStore(input) {
-    const store = input.kind === 'user' ? userStore(input.root) : input.kind === 'project' ? projectStore(input.root) : providerStore(input.root);
-    if (store.kind !== 'project')
-        mkdirSync(store.root, { recursive: true, mode: 0o700 });
-    const initialize = () => {
-        if (store.kind === 'project')
-            discardIncompleteScopedStore(store);
-        if (scopedStoreExists(store))
-            return;
-        const legacyPath = legacyScopedStorePaths(store).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, store.kind);
-            if (store.kind !== 'provider')
-                writeOwnerRoot(db, store.kind, store.root);
-        });
-    };
-    if (store.kind === 'project')
-        withProjectStateLock(store.root, initialize);
-    else
-        withExclusiveDirectoryLock(join(store.root, '.init.lock'), initialize);
-}
-export function openScopedStore(store) {
-    if (layoutNeedsMigration())
-        throw new Error('layout_migration_required');
-    const cached = handles.get(store.path);
-    if (cached !== undefined)
-        return cached;
-    initializeFreshScopedStore(store);
-    const db = new DatabaseSync(store.path);
-    try {
-        db.exec('PRAGMA busy_timeout = 5000; PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON;');
-        upgradeScopedStore(db, store);
-        assertVersion(db, store);
-        secure(store.path);
-        handles.set(store.path, db);
-        return db;
-    }
-    catch (error) {
-        db.close();
-        throw error;
-    }
-}
-export function createScopedStore(store, create) {
-    if (existsSync(store.path))
-        throw new Error(`scoped SQL store already exists: ${store.path}`);
-    if (store.kind !== 'project')
-        mkdirSync(store.root, { recursive: true, mode: 0o700 });
-    if (!statSync(store.root).isDirectory())
-        throw new Error(`scoped SQL root is not a directory: ${store.root}`);
-    if (store.kind !== 'project' || process.platform !== 'linux')
-        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();
-    }
-    // Closing checkpoints the WAL into the database file. Force the finished file and its
-    // directory entry to stable storage so a volume handed off right after first boot never
-    // comes back with the empty, schema-less file that `scoped SQL store is uninitialized` names.
-    syncFile(store.path);
-    syncDirectory(store.root);
-}
-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()) {
-        forgetPrepared(db);
-        db.close();
-    }
-    handles.clear();
-}

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

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