@jini-ai/server 0.0.0-stage → 0.5.0

package/dist/index.js

@@ -0,0 +1,11 @@
+export { buildDaemonDbOperations, classifyRunFailureForRetry, createLocalNodeDaemon, projectDetectedAgent, resolveBoundPort, resolveReportHost, } from './create-local-node-daemon.js';
+export { composeJiniKernel, defaultServerMessages } from './compose-jini-kernel.js';
+export { CAPABILITY_IDS, CORE_CAPABILITIES, defineJiniFeature, isCapabilityId, JINI_PROFILES } from './feature.js';
+export { resolveFeatureActivation } from './feature-activation.js';
+export { ANONYMOUS_DELEGATED_PRINCIPAL, createBuiltInFeatures, LOCAL_DAEMON_PRINCIPAL, } from './builtin-features.js';
+export { createJiniKernelBase } from './kernel-base.js';
+// Frontend control belongs to the daemon HTTP surface: hosts that build their own Express app
+// can compose it without the server kernel. This server entry keeps its existing public export.
+export { createFrontendControl } from '@jini-ai/daemon/http';
+export { DEFAULT_DAEMON_BIND_HOST, closeHttpServer, installGracefulShutdown, normalizeDaemonBindHost, } from './host-bootstrap.js';
+//# sourceMappingURL=index.js.map

package/dist/kernel-base.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @module kernel-base
+ *
+ * The infrastructure every composition owns regardless of which features it activates: the durable
+ * (or in-memory) event log, the run lifecycle, the byte journal, the agent executor, the one shared
+ * `ToolRegistry`/`ToolExecutor` pair, and — for sqlite storage — the raw database connection.
+ *
+ * **The database connection belongs here, not to a feature.** It is borrowed by the readiness probe
+ * (`health`), by the raw db-operations tools (`daemonDb`), and by the durable tool catalog
+ * (`toolCatalog`) — three independently-selectable features. Had any one of them owned it, disabling
+ * that feature would have silently broken the others: turning off `daemonDb` would leave `health`'s
+ * readiness probe with nothing to check, which is a much worse failure than the one it was meant to
+ * simplify, because a readiness probe that stops probing still answers `200`. Ownership by the base,
+ * borrowing by features, is what makes the feature set genuinely independent.
+ */
+import { type SqliteDb, type SqliteSyncOpener } from '@jini-ai/db/sqlite';
+import { type ToolRegistry } from '@jini-ai/core';
+import { createAgentExecutor, type AgentExecutor, type EventLog, type RunLifecycle, type RunRetrySideEffectState, type ToolExecutor } from '@jini-ai/daemon';
+/** Where a composition's durable state lives. */
+export type JiniKernelStorage = 
+/** No files touched. Runs and their events vanish with the process — right for tests and for an
+ * embedded host that treats runs as ephemeral. Features needing a real database file
+ * (`daemonDb`, `toolCatalog`, `xai`) cannot be activated against it. */
+{
+    readonly kind: 'memory';
+}
+/** `<dataDir>/events.db` + `<dataDir>/journal.db`. The directory must already exist. */
+ | {
+    readonly kind: 'sqlite';
+    readonly dataDir: string;
+    readonly open: SqliteSyncOpener;
+};
+/** The raw sqlite handle and its path, borrowed by `health`/`daemonDb`/`toolCatalog`. */
+export interface KernelSqliteAccess {
+    readonly connection: SqliteDb;
+    readonly eventsDbPath: string;
+    readonly dataDir: string;
+}
+/**
+ * An `EventLog` that may or may not hold an OS resource. `@jini-ai/daemon/store/event-log/sqlite`'s `SqliteEventLog` adds
+ * `close({})`; `@jini-ai/daemon`'s in-memory reference adapter has nothing to release and so declares
+ * none. Modelling `close` as optional lets the base treat both storage kinds uniformly instead of
+ * branching on which one it happens to hold.
+ */
+export type ClosableEventLog = EventLog & {
+    close?: (requiredArgs: Record<string, never>) => Promise<void>;
+};
+export interface JiniKernelBase {
+    readonly eventLog: ClosableEventLog;
+    readonly journalEventLog: ClosableEventLog;
+    readonly lifecycle: RunLifecycle;
+    readonly agentExecutor: AgentExecutor;
+    /** The single registry every active feature's tools land in, and the only one `toolExecutor` reads. */
+    readonly registry: ToolRegistry;
+    readonly toolExecutor: ToolExecutor;
+    /** `null` under memory storage. Owned here; features borrow and must never close it. */
+    readonly sqlite: KernelSqliteAccess | null;
+    /** Closes every handle this base opened, in the same order the standalone daemon always has. */
+    close(): Promise<void>;
+}
+export interface CreateJiniKernelBaseOptions {
+    readonly storage: JiniKernelStorage;
+    /** Extra `createAgentExecutor` options (e.g. `mcpJsonInjection`). `lifecycle`/`journal`/`classifyFailure` are kernel-owned. */
+    readonly agentExecutor?: Omit<NonNullable<Parameters<typeof createAgentExecutor>[1]>, 'journal' | 'classifyFailure'>;
+}
+/**
+ * The zero-config retry classifier every composition gets. Delegates entirely to `@jini-ai/daemon`'s
+ * `resumableFromProcessExit` — see that function's own doc for the classification policy.
+ */
+export declare function classifyRunFailureForRetry(context: {
+    code: number | null;
+    signal: string | null;
+    sideEffects?: Pick<RunRetrySideEffectState, 'userVisibleOutputSeen' | 'toolCallSeen'>;
+}): boolean;
+/**
+ * Opens every kernel-owned resource and rehydrates durable run history.
+ *
+ * @throws If rehydration fails against a corrupt or unreadable durable history. Every handle this
+ * call had already opened is closed before it rethrows, so a failed boot never leaks a sqlite file
+ * handle — the invariant the standalone daemon has always maintained.
+ */
+export declare function createJiniKernelBase(options: CreateJiniKernelBaseOptions): Promise<JiniKernelBase>;
+//# sourceMappingURL=kernel-base.d.ts.map

package/dist/kernel-base.js

@@ -0,0 +1,125 @@
+/**
+ * @module kernel-base
+ *
+ * The infrastructure every composition owns regardless of which features it activates: the durable
+ * (or in-memory) event log, the run lifecycle, the byte journal, the agent executor, the one shared
+ * `ToolRegistry`/`ToolExecutor` pair, and — for sqlite storage — the raw database connection.
+ *
+ * **The database connection belongs here, not to a feature.** It is borrowed by the readiness probe
+ * (`health`), by the raw db-operations tools (`daemonDb`), and by the durable tool catalog
+ * (`toolCatalog`) — three independently-selectable features. Had any one of them owned it, disabling
+ * that feature would have silently broken the others: turning off `daemonDb` would leave `health`'s
+ * readiness probe with nothing to check, which is a much worse failure than the one it was meant to
+ * simplify, because a readiness probe that stops probing still answers `200`. Ownership by the base,
+ * borrowing by features, is what makes the feature set genuinely independent.
+ */
+import { openSqliteConnection } from '@jini-ai/db/sqlite';
+import { join } from 'node:path';
+import { createToolRegistry } from '@jini-ai/core';
+import { createAgentExecutor, createInMemoryEventLog, createRunByteJournal, createRunLifecycle, createToolExecutor, resumableFromProcessExit, } from '@jini-ai/daemon';
+import { openSqliteEventLog } from '@jini-ai/daemon/store/event-log/sqlite';
+/**
+ * The zero-config retry classifier every composition gets. Delegates entirely to `@jini-ai/daemon`'s
+ * `resumableFromProcessExit` — see that function's own doc for the classification policy.
+ */
+export function classifyRunFailureForRetry(context) {
+    return resumableFromProcessExit({ code: context.code, signal: context.signal }, context.sideEffects === undefined ? {} : { sideEffects: context.sideEffects });
+}
+/**
+ * Opens every kernel-owned resource and rehydrates durable run history.
+ *
+ * @throws If rehydration fails against a corrupt or unreadable durable history. Every handle this
+ * call had already opened is closed before it rethrows, so a failed boot never leaks a sqlite file
+ * handle — the invariant the standalone daemon has always maintained.
+ */
+export async function createJiniKernelBase(options) {
+    const sqliteStorage = options.storage.kind === 'sqlite' ? options.storage : null;
+    const dataDir = sqliteStorage?.dataDir ?? null;
+    const eventsDbPath = dataDir === null ? null : join(dataDir, 'events.db');
+    // One acquisition block, one cleanup path — and **every** acquisition is inside it. Opening even
+    // the first event log outside the block would reintroduce exactly the leak this shape exists to
+    // prevent: `events.db` opens, `journal.db` fails (corrupt file, or a directory sitting where a
+    // database was expected), and the first handle stays open for the lifetime of a process that has
+    // no kernel. The second sqlite connection and the rehydration are grouped here for the same
+    // reason: all four can fail after handles are already open, and two try/catch blocks with
+    // near-identical cleanup is how one of them eventually drifts and starts leaking.
+    const opened = [];
+    const openEventLog = (path) => {
+        let log;
+        if (path === null)
+            log = createInMemoryEventLog({});
+        else {
+            // A non-null path is derived only from sqliteStorage above.
+            log = openSqliteEventLog({ file: path, open: sqliteStorage.open });
+        }
+        opened.push(log);
+        return log;
+    };
+    let sqlite = null;
+    let featureConnection;
+    let eventLog;
+    let journalEventLog;
+    let lifecycle;
+    let journal;
+    try {
+        eventLog = openEventLog(eventsDbPath);
+        // Gap 1's byte journal gets its own store, deliberately separate from `eventLog`: that log
+        // replays every entry it holds to SSE subscribers as a `RunProtocolEvent`, and a journal entry
+        // has no corresponding protocol-event kind.
+        journalEventLog = openEventLog(dataDir === null ? null : join(dataDir, 'journal.db'));
+        if (sqliteStorage && eventsDbPath !== null && dataDir !== null) {
+            // A *second* connection to the same `events.db` the log above owns — safe: both run in WAL
+            // mode, which permits multiple concurrently open handles on one file within a single process.
+            featureConnection = openSqliteConnection({ filePath: eventsDbPath, open(file, settings) {
+                    featureConnection = sqliteStorage.open(file, settings);
+                    return featureConnection;
+                } });
+            sqlite = { connection: featureConnection, eventsDbPath, dataDir };
+        }
+        journal = createRunByteJournal({ eventLog: journalEventLog });
+        lifecycle = createRunLifecycle({ eventLog });
+        await lifecycle.rehydrate({});
+    }
+    catch (error) {
+        // Every acquired handle is attempted even if another closer fails. Preserve the boot error.
+        try {
+            featureConnection?.close();
+        }
+        catch { /* Keep the boot failure. */ }
+        await Promise.allSettled(opened.map((log) => log.close?.({})));
+        throw error;
+    }
+    const agentExecutor = createAgentExecutor({ lifecycle }, {
+        ...options.agentExecutor,
+        journal,
+        classifyFailure: classifyRunFailureForRetry,
+    });
+    const registry = createToolRegistry({});
+    // Created eagerly against the still-empty registry, and that is correct: `ToolExecutor` resolves
+    // a registration at execute time, not at construction, so features composed later can contribute
+    // tools this executor will find. It is what lets a feature's routes take the executor as a
+    // dependency while its own tools register in the same pass.
+    const toolExecutor = createToolExecutor({ registry });
+    let closed = null;
+    return {
+        eventLog,
+        journalEventLog,
+        lifecycle,
+        agentExecutor,
+        registry,
+        toolExecutor,
+        sqlite,
+        close() {
+            closed ??= (async () => {
+                try {
+                    sqlite?.connection.close();
+                }
+                finally {
+                    await Promise.all([eventLog.close?.({}), journalEventLog.close?.({})]);
+                }
+            })();
+            return closed;
+        },
+    };
+}
+//# sourceMappingURL=kernel-base.js.map

package/dist/lifecycle/boot-lifecycle.d.ts

@@ -0,0 +1,61 @@
+/** Two-stage boot orchestration. Modules clean up their own partially failed stage. */
+export type ModuleLifecycleStatus = {
+    status: 'ready';
+} | {
+    status: 'disabled';
+    reasonCode: string;
+    remediationHint: string;
+} | {
+    status: 'failed';
+    reasonCode: string;
+    remediationHint: string;
+};
+export type BootCriticality = 'critical' | 'optional';
+export interface BootModule {
+    name: string;
+    owner: string;
+    criticality: BootCriticality;
+    /** Acquire reversible resources; do not start external work yet. */
+    prepare(): Promise<void>;
+    start(): Promise<void>;
+    /** Idempotent; never called on the module whose current stage failed. */
+    stop(): Promise<void>;
+}
+export interface BootModuleResult {
+    name: string;
+    owner: string;
+    criticality: BootCriticality;
+    lifecycle: ModuleLifecycleStatus;
+}
+export interface BootResult {
+    ok: boolean;
+    modules: BootModuleResult[];
+}
+export interface ReadinessStore {
+    set(required: {
+        snapshot: BootResult;
+    }): void;
+    get(): BootResult;
+}
+export interface LifecycleReporter {
+    report(required: {
+        result: BootResult;
+    }): void;
+}
+/**
+ * Preserve source rollback semantics: prepare failure unwinds completed preparations;
+ * start failure unwinds completed starts only. Failing modules own their partial cleanup.
+ * Prepared modules not yet started on a start-stage abort remain host-owned.
+
+ * Contract rationale (including readiness ownership):
+ * Ports: `BootModule`, `ReadinessStore`, optional `LifecycleReporter`. `runBootLifecycle({ modules }, { readiness, reporter })` runs all preparations before starts. Optional failures do not set `ok=false`; critical failures stop the stage and unwind completed modules in reverse order. The failing module self-cleans. The existing start-stage rollback stops only modules that completed start, leaving other prepared resources host-owned; this extraction deliberately preserves that source behavior. A ready record for an unwound module retains the original source status.
+ *
+ * `createReadinessStore({}, { initial })` owns defensive snapshot copies per instance. No module-global state or synthetic daemon name. Keep daemon health latching in the host and compose it with this store. Duplicate module names now reject before acquisition; reporter failure is best effort. Lifecycle calls can be concurrent only if callers provide separate modules/stores or coordinate their own boot.
+ */
+export declare function runBootLifecycle(required: {
+    modules: readonly BootModule[];
+}, optional?: {
+    readiness?: ReadinessStore;
+    reporter?: LifecycleReporter;
+}): Promise<BootResult>;
+//# sourceMappingURL=boot-lifecycle.d.ts.map

package/dist/lifecycle/boot-lifecycle.js

@@ -0,0 +1,74 @@
+async function stopInReverse(modules) {
+    for (const module of [...modules].reverse()) {
+        try {
+            await module.stop();
+        }
+        catch { /* Preserve the original failure and continue cleanup. */ }
+    }
+}
+/**
+ * Preserve source rollback semantics: prepare failure unwinds completed preparations;
+ * start failure unwinds completed starts only. Failing modules own their partial cleanup.
+ * Prepared modules not yet started on a start-stage abort remain host-owned.
+
+ * Contract rationale (including readiness ownership):
+ * Ports: `BootModule`, `ReadinessStore`, optional `LifecycleReporter`. `runBootLifecycle({ modules }, { readiness, reporter })` runs all preparations before starts. Optional failures do not set `ok=false`; critical failures stop the stage and unwind completed modules in reverse order. The failing module self-cleans. The existing start-stage rollback stops only modules that completed start, leaving other prepared resources host-owned; this extraction deliberately preserves that source behavior. A ready record for an unwound module retains the original source status.
+ *
+ * `createReadinessStore({}, { initial })` owns defensive snapshot copies per instance. No module-global state or synthetic daemon name. Keep daemon health latching in the host and compose it with this store. Duplicate module names now reject before acquisition; reporter failure is best effort. Lifecycle calls can be concurrent only if callers provide separate modules/stores or coordinate their own boot.
+ */
+export async function runBootLifecycle(required, optional = {}) {
+    const modules = [...required.modules];
+    if (new Set(modules.map(module => module.name)).size !== modules.length) {
+        throw new Error('boot module names must be unique');
+    }
+    const results = new Map();
+    const prepared = [];
+    const ready = [];
+    let aborted = false;
+    for (const stage of ['prepare', 'start']) {
+        const completed = stage === 'prepare' ? prepared : ready;
+        for (const module of stage === 'prepare' ? modules : prepared) {
+            try {
+                await module[stage]();
+                completed.push(module);
+                if (stage === 'start')
+                    results.set(module.name, {
+                        name: module.name, owner: module.owner, criticality: module.criticality,
+                        lifecycle: { status: 'ready' },
+                    });
+            }
+            catch (error) {
+                results.set(module.name, {
+                    name: module.name, owner: module.owner, criticality: module.criticality,
+                    lifecycle: {
+                        status: 'failed', reasonCode: error instanceof Error ? error.message : String(error),
+                        remediationHint: 'check the boot log for the underlying error and retry after fixing it',
+                    },
+                });
+                if (module.criticality === 'critical') {
+                    await stopInReverse(completed);
+                    aborted = true;
+                    break;
+                }
+            }
+        }
+        if (aborted)
+            break;
+    }
+    const ordered = modules.flatMap(module => {
+        const result = results.get(module.name);
+        return result === undefined ? [] : [result];
+    });
+    const result = {
+        ok: ordered.every(module => module.criticality !== 'critical' || module.lifecycle.status === 'ready'),
+        modules: ordered,
+    };
+    optional.readiness?.set({ snapshot: result });
+    // A reporter must never turn a completed boot into an apparent failure.
+    try {
+        optional.reporter?.report({ result });
+    }
+    catch { /* Best-effort reporting. */ }
+    return result;
+}
+//# sourceMappingURL=boot-lifecycle.js.map

package/dist/lifecycle/index.d.ts

@@ -0,0 +1,3 @@
+export * from './boot-lifecycle.js';
+export * from './readiness-state.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lifecycle/index.js

@@ -0,0 +1,3 @@
+export * from './boot-lifecycle.js';
+export * from './readiness-state.js';
+//# sourceMappingURL=index.js.map

package/dist/lifecycle/readiness-state.d.ts

@@ -0,0 +1,6 @@
+import type { BootResult, ReadinessStore } from './boot-lifecycle.js';
+/** Instance-owned snapshots. Host-specific health records are supplied by the caller. */
+export declare function createReadinessStore(required: Record<string, never>, optional?: {
+    initial?: BootResult;
+}): ReadinessStore;
+//# sourceMappingURL=readiness-state.d.ts.map

package/dist/lifecycle/readiness-state.js

@@ -0,0 +1,15 @@
+function copy(snapshot) {
+    return { ok: snapshot.ok, modules: snapshot.modules.map(module => ({
+            ...module, lifecycle: { ...module.lifecycle },
+        })) };
+}
+/** Instance-owned snapshots. Host-specific health records are supplied by the caller. */
+export function createReadinessStore(required, optional = {}) {
+    void required;
+    let snapshot = copy(optional.initial ?? { ok: true, modules: [] });
+    return {
+        set({ snapshot: next }) { snapshot = copy(next); },
+        get() { return copy(snapshot); },
+    };
+}
+//# sourceMappingURL=readiness-state.js.map

package/dist/storage/backend-config.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @module backend-config
+ *
+ * Resolves which SQL backend a host daemon should use from environment
+ * variables. v1 ships local SQLite via an injected `better-sqlite3` opener (the event-log adapter
+ * now belongs to the daemon's storage subpath);
+ * a `postgres` selection is recorded so a future adapter can read it, but
+ * `resolveSqliteBackendConfig` never opens a connection itself — it only
+ * pins the parameter surface (host/port/database/user/sslMode) so a
+ * follow-up package can land the adapter without re-litigating the env-var
+ * contract.
+ */
+export type SqliteBackendKind = 'sqlite' | 'postgres';
+export interface SqliteBackendConfig {
+    kind: SqliteBackendKind;
+    /** Resolution metadata a future Postgres adapter will read. */
+    postgres?: {
+        host: string;
+        port: number;
+        database: string;
+        user: string;
+        /**
+         * Password / connection string are looked up at runtime from the
+         * caller's own secret manager; this layer never reads them through env.
+         */
+        sslMode?: 'disable' | 'require' | 'verify-full';
+    };
+}
+export declare class SqliteBackendConfigError extends Error {
+    constructor({ message }: {
+        message: string;
+    });
+}
+/**
+ * Reads `JINI_SQLITE_BACKEND` (`'sqlite'` default, or `'postgres'`) and, for
+ * `postgres`, `JINI_PG_HOST`/`JINI_PG_PORT`/`JINI_PG_DATABASE`/`JINI_PG_USER`/
+ * `JINI_PG_SSL_MODE` from the given env map (defaults to `process.env`).
+ *
+ * @param required - No required configuration values; pass an empty argument object.
+ * @param optional.env - Environment map to read from. Defaults to `process.env`.
+ * @returns The resolved backend config.
+ * @throws {SqliteBackendConfigError} When `kind` is unrecognized, or `postgres`
+ *   is selected without the required host/database/user.
+ */
+export declare function resolveSqliteBackendConfig(required: Record<string, never>, optional?: {
+    env?: Record<string, string | undefined>;
+}): SqliteBackendConfig;
+//# sourceMappingURL=backend-config.d.ts.map

package/dist/storage/backend-config.js

@@ -0,0 +1,61 @@
+/**
+ * @module backend-config
+ *
+ * Resolves which SQL backend a host daemon should use from environment
+ * variables. v1 ships local SQLite via an injected `better-sqlite3` opener (the event-log adapter
+ * now belongs to the daemon's storage subpath);
+ * a `postgres` selection is recorded so a future adapter can read it, but
+ * `resolveSqliteBackendConfig` never opens a connection itself — it only
+ * pins the parameter surface (host/port/database/user/sslMode) so a
+ * follow-up package can land the adapter without re-litigating the env-var
+ * contract.
+ */
+export class SqliteBackendConfigError extends Error {
+    constructor({ message }) {
+        super(message);
+        this.name = 'SqliteBackendConfigError';
+    }
+}
+/**
+ * Reads `JINI_SQLITE_BACKEND` (`'sqlite'` default, or `'postgres'`) and, for
+ * `postgres`, `JINI_PG_HOST`/`JINI_PG_PORT`/`JINI_PG_DATABASE`/`JINI_PG_USER`/
+ * `JINI_PG_SSL_MODE` from the given env map (defaults to `process.env`).
+ *
+ * @param required - No required configuration values; pass an empty argument object.
+ * @param optional.env - Environment map to read from. Defaults to `process.env`.
+ * @returns The resolved backend config.
+ * @throws {SqliteBackendConfigError} When `kind` is unrecognized, or `postgres`
+ *   is selected without the required host/database/user.
+ */
+export function resolveSqliteBackendConfig(required, optional = {}) {
+    void required;
+    const e = optional.env ?? process.env;
+    const kind = (e.JINI_SQLITE_BACKEND ?? 'sqlite').trim().toLowerCase();
+    if (kind === 'postgres') {
+        const host = e.JINI_PG_HOST ?? '';
+        const portStr = e.JINI_PG_PORT ?? '5432';
+        const database = e.JINI_PG_DATABASE ?? '';
+        const user = e.JINI_PG_USER ?? '';
+        const sslMode = e.JINI_PG_SSL_MODE === 'disable' || e.JINI_PG_SSL_MODE === 'verify-full' ? e.JINI_PG_SSL_MODE : 'require';
+        if (!host || !database || !user) {
+            throw new SqliteBackendConfigError({ message: 'JINI_SQLITE_BACKEND=postgres requires JINI_PG_HOST, JINI_PG_DATABASE, JINI_PG_USER. ' +
+                    'JINI_PG_PORT defaults to 5432; JINI_PG_SSL_MODE defaults to "require".',
+            });
+        }
+        return {
+            kind: 'postgres',
+            postgres: {
+                host,
+                port: Number.parseInt(portStr, 10) || 5432,
+                database,
+                user,
+                sslMode,
+            },
+        };
+    }
+    if (kind !== 'sqlite' && kind !== '') {
+        throw new SqliteBackendConfigError({ message: `unknown JINI_SQLITE_BACKEND value '${kind}'. Accepted: 'sqlite' (default), 'postgres'.` });
+    }
+    return { kind: 'sqlite' };
+}
+//# sourceMappingURL=backend-config.js.map

package/dist/storage/index.d.ts

@@ -0,0 +1,3 @@
+/** Host backend selection only; never opens a database or imports a driver. */
+export * from './backend-config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.js

@@ -0,0 +1,3 @@
+/** Host backend selection only; never opens a database or imports a driver. */
+export * from './backend-config.js';
+//# sourceMappingURL=index.js.map

package/dist/storage/legacy/sqlite.d.ts

@@ -0,0 +1,26 @@
+import fs from 'node:fs';
+import { type SqliteDb, type SqliteSyncOpener } from '@jini-ai/db/sqlite';
+/**
+ * Explicit idempotent bootstrap of unchanged legacy tables; no versioned migration ledger.
+ * @param db Borrowed host handle; this operation neither opens nor closes it.
+ * @complexity O(1) schema statements.
+ */
+export declare function migrate({ db }: {
+    db: SqliteDb;
+}): void;
+/**
+ * Opens/caches <dataDir>/app.sqlite using the injected opener, WAL and foreign keys.
+ * A new path closes the previous singleton; setup failure closes only the newly acquired handle.
+ * @throws The original host acquisition/schema failure, or a missing opener.
+ * @complexity O(1) acquisition/bootstrap calls, independent of stored row count.
+ */
+export declare function openDatabase({ projectRoot, open }: {
+    projectRoot: string;
+    open: SqliteSyncOpener;
+}, options?: {
+    dataDir?: string;
+    filesystem?: Pick<typeof fs, 'mkdirSync'>;
+}): SqliteDb;
+/** Close the active owned singleton once; clearing state first permits a clean retry after failure. */
+export declare function closeDatabase(): void;
+//# sourceMappingURL=sqlite.d.ts.map

package/dist/storage/legacy/sqlite.js

@@ -0,0 +1,63 @@
+/** Local app.sqlite singleton policy; the host explicitly supplies its SQLite driver. */
+import path from 'node:path';
+import fs from 'node:fs';
+import { openSqliteConnection } from '@jini-ai/db/sqlite';
+import { LEGACY_CHAT_DDL } from '@jini-ai/chat/store/legacy/sqlite';
+import { LEGACY_AGENT_SESSIONS_DDL } from '@jini-ai/daemon/store/agent-sessions/sqlite';
+import { LEGACY_PROJECTS_DDL } from '../../store/projects/sqlite.js';
+let dbInstance = null;
+let dbFile = null;
+/**
+ * Explicit idempotent bootstrap of unchanged legacy tables; no versioned migration ledger.
+ * @param db Borrowed host handle; this operation neither opens nor closes it.
+ * @complexity O(1) schema statements.
+ */
+// Only generic engine tables belong in this bootstrap; consumer feature tables and migrations
+// stay in host adapters. Every legacy column is declared in the base DDL, so this is not an
+// ALTER TABLE migration path for a consumer's pre-existing product schema.
+// Catalog tables are created only by hosts that actually seed and query them. A parallel execution
+// table would also weaken the existing ToolExecutionAuditRecord (principal, run and phase data);
+// durable audit storage should preserve that record rather than introduce a second audit noun.
+export function migrate({ db }) {
+    db.exec(LEGACY_PROJECTS_DDL + LEGACY_CHAT_DDL + LEGACY_AGENT_SESSIONS_DDL);
+}
+/**
+ * Opens/caches <dataDir>/app.sqlite using the injected opener, WAL and foreign keys.
+ * A new path closes the previous singleton; setup failure closes only the newly acquired handle.
+ * @throws The original host acquisition/schema failure, or a missing opener.
+ * @complexity O(1) acquisition/bootstrap calls, independent of stored row count.
+ */
+export function openDatabase({ projectRoot, open }, options = {}) {
+    // Keep the historical refusal text for JavaScript callers that omit the required port.
+    if (!open)
+        throw new Error('openDatabase: inject options.open');
+    const dir = options.dataDir ? path.resolve(options.dataDir) : path.join(projectRoot, '.jini');
+    const file = path.join(dir, 'app.sqlite');
+    if (dbInstance && dbFile === file)
+        return dbInstance;
+    closeDatabase();
+    (options.filesystem ?? fs).mkdirSync(dir, { recursive: true });
+    let db;
+    try {
+        db = openSqliteConnection({ filePath: file, open(file, settings) { db = open(file, settings); return db; }, pragmas: ['journal_mode = WAL', 'foreign_keys = ON'] });
+        migrate({ db });
+        dbInstance = db;
+        dbFile = file;
+        return db;
+    }
+    catch (error) {
+        try {
+            db?.close();
+        }
+        catch { /* Keep the original bootstrap failure. */ }
+        throw error;
+    }
+}
+/** Close the active owned singleton once; clearing state first permits a clean retry after failure. */
+export function closeDatabase() {
+    const db = dbInstance;
+    dbInstance = null;
+    dbFile = null;
+    db?.close();
+}
+//# sourceMappingURL=sqlite.js.map