@rynx-ai/daemon 0.1.0

package/dist/plugin-installer.js

@@ -0,0 +1,186 @@
+/**
+ * Plugin installation — from npm or a local directory.
+ *
+ * No trust mechanism: installing runs the plugin's code in the daemon process.
+ * The user owns that risk.
+ *
+ *  - **npm**:   `npm install <spec>` into `~/.rynx/plugins`, then record it.
+ *  - **local**: register an absolute directory and load it in place (no copy;
+ *               supports local development / offline). The directory must be a
+ *               ready package (built, deps installed, exporting `plugin`).
+ *
+ * After recording, the channel-type catalog is rebuilt so a freshly-installed
+ * plugin's types are usable without a daemon restart.
+ */
+import { spawn } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getPlugin, removePlugin, upsertPlugin, } from "./plugin-store.js";
+import { importPluginManifest, pluginPkgDir, pluginsDir } from "./registry.js";
+/** A spec is "local" if it's a path/file: URL or an existing directory. */
+function detectSource(spec) {
+    if (spec.startsWith("file:"))
+        return "local";
+    if (spec.startsWith("~") || spec.startsWith("./") || spec.startsWith("../") || isAbsolute(spec)) {
+        return "local";
+    }
+    try {
+        if (existsSync(spec) && statSync(spec).isDirectory())
+            return "local";
+    }
+    catch {
+        /* not a path */
+    }
+    return "npm";
+}
+function toLocalDir(spec) {
+    let p = spec.startsWith("file:") ? fileURLToPath(spec) : spec;
+    if (p === "~" || p.startsWith("~/"))
+        p = join(homedir(), p.slice(1));
+    return resolve(p);
+}
+/** Package name from an npm spec, dropping any version range (`x@^1` → `x`). */
+function npmPackageName(spec) {
+    const at = spec.lastIndexOf("@");
+    return at > 0 ? spec.slice(0, at) : spec;
+}
+/**
+ * Install (or re-install) a plugin from an npm spec or a local directory.
+ *  - **local**: copy the package (minus `node_modules`) into `~/.rynx/plugins/<name>`
+ *    and load it there. The plugin must be self-contained — it bundles its deps at
+ *    build time (incl. the unpublished workspace `@rynx-ai/core`) and declares a
+ *    `rynx.plugin` entry; the daemon installs nothing.
+ *  - **npm**: `npm install` into `~/.rynx/plugins` (deps resolved by npm).
+ *
+ * `onConflict` is consulted when a plugin of the same `name` already exists; if it
+ * returns false the install is aborted with `{ skipped: true }` (nothing changes).
+ * `onProgress` streams human-readable lines.
+ */
+export async function installPlugin(spec, onProgress = () => { }, opts = {}) {
+    const source = detectSource(spec);
+    let pkgDir;
+    let storedSpec;
+    if (source === "local") {
+        const srcDir = toLocalDir(spec);
+        if (!existsSync(join(srcDir, "package.json")))
+            throw new Error(`no package.json at ${srcDir}`);
+        const name = (await importPluginManifest(srcDir))?.name;
+        if (!name)
+            throw new Error(`package at ${srcDir} has no valid \`plugin\` export`);
+        if (await declined(name, opts.onConflict))
+            return { name, source, skipped: true };
+        const dest = join(pluginsDir(), name);
+        ensurePluginsRoot(pluginsDir());
+        rmSync(dest, { recursive: true, force: true });
+        // A self-contained plugin bundles its deps, so node_modules is never copied.
+        cpSync(srcDir, dest, { recursive: true, filter: (p) => basename(p) !== "node_modules" });
+        onProgress(`copied local plugin "${name}" → ${dest}`);
+        pkgDir = dest;
+        storedSpec = dest;
+    }
+    else {
+        const dir = pluginsDir();
+        ensurePluginsRoot(dir);
+        onProgress(`npm install ${spec}`);
+        await runNpm(["install", spec, "--prefix", dir, "--no-audit", "--no-fund", "--save"], onProgress, opts.signal);
+        storedSpec = npmPackageName(spec);
+        pkgDir = pluginPkgDir({ source, spec: storedSpec });
+        const name = (await importPluginManifest(pkgDir))?.name;
+        if (!name)
+            throw new Error(`package at ${pkgDir} has no valid \`plugin\` export`);
+        if (await declined(name, opts.onConflict))
+            return { name, source, skipped: true };
+    }
+    const manifest = await importPluginManifest(pkgDir);
+    if (!manifest || typeof manifest.name !== "string" || !manifest.name) {
+        throw new Error(`package at ${pkgDir} has no valid \`plugin\` export`);
+    }
+    const version = readVersion(pkgDir);
+    upsertPlugin({ name: manifest.name, spec: storedSpec, source, version });
+    onProgress(`installed plugin "${manifest.name}"${version ? `@${version}` : ""}`);
+    return { name: manifest.name, source, version };
+}
+/** A same-named plugin already exists and `onConflict` says don't overwrite. */
+async function declined(name, onConflict) {
+    if (!onConflict)
+        return false;
+    const existing = getPlugin(name);
+    if (!existing)
+        return false;
+    return !(await onConflict(existing));
+}
+/** Uninstall a plugin: drop its record, npm-uninstall if applicable, refresh catalog. */
+export async function uninstallPlugin(name, onProgress = () => { }) {
+    const rec = getPlugin(name);
+    if (!rec)
+        return false;
+    if (rec.source === "npm") {
+        try {
+            await runNpm(["uninstall", rec.spec, "--prefix", pluginsDir(), "--no-audit", "--no-fund"], onProgress);
+        }
+        catch (error) {
+            onProgress(`npm uninstall warning: ${messageOf(error)}`);
+        }
+    }
+    else {
+        // local: remove the copied package dir — but only if it lives under our plugins
+        // root (older records may point at an in-place source tree; never delete that).
+        const dir = pluginPkgDir(rec);
+        if (dirname(dir) === pluginsDir()) {
+            try {
+                rmSync(dir, { recursive: true, force: true });
+                onProgress(`removed ${dir}`);
+            }
+            catch (error) {
+                onProgress(`remove warning: ${messageOf(error)}`);
+            }
+        }
+    }
+    removePlugin(name);
+    onProgress(`uninstalled plugin "${name}"`);
+    return true;
+}
+function ensurePluginsRoot(dir) {
+    mkdirSync(dir, { recursive: true });
+    const pkg = join(dir, "package.json");
+    if (!existsSync(pkg)) {
+        writeFileSync(pkg, `${JSON.stringify({ name: "rynx-plugins", private: true, version: "0.0.0" }, null, 2)}\n`);
+    }
+}
+function readVersion(pkgDir) {
+    try {
+        return JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf8"))
+            .version;
+    }
+    catch {
+        return undefined;
+    }
+}
+function runNpm(args, onProgress, signal) {
+    return new Promise((resolveDone, reject) => {
+        const child = spawn("npm", args, { stdio: ["ignore", "pipe", "pipe"] });
+        const abort = () => child.kill();
+        signal?.addEventListener("abort", abort, { once: true });
+        const onData = (buf) => {
+            for (const line of buf.toString().split(/\r?\n/)) {
+                if (line.trim())
+                    onProgress(line);
+            }
+        };
+        child.stdout?.on("data", onData);
+        child.stderr?.on("data", onData);
+        child.on("error", reject);
+        child.on("close", (code) => {
+            signal?.removeEventListener("abort", abort);
+            if (code === 0)
+                resolveDone();
+            else
+                reject(new Error(`npm exited with code ${code ?? "null"}`));
+        });
+    });
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/plugin-store.d.ts

@@ -0,0 +1,27 @@
+export type PluginSource = "npm" | "local";
+export interface PluginRecord {
+    /** Canonical plugin name (short id, e.g. `lark`); primary key. */
+    name: string;
+    /** Install spec: an npm package spec, or an absolute local directory. */
+    spec: string;
+    source: PluginSource;
+    version?: string;
+    enabled: boolean;
+    installedAt: string;
+}
+/** All installed plugins, enabled or not. */
+export declare function listPlugins(): PluginRecord[];
+/** Only enabled plugins — the set the loader imports. */
+export declare function listEnabledPlugins(): PluginRecord[];
+export declare function getPlugin(name: string): PluginRecord | undefined;
+/** Insert or replace a plugin record (idempotent install). */
+export declare function upsertPlugin(rec: {
+    name: string;
+    spec: string;
+    source: PluginSource;
+    version?: string;
+    enabled?: boolean;
+}): void;
+export declare function setPluginEnabled(name: string, enabled: boolean): void;
+/** Remove a plugin record. Returns false if it wasn't present. */
+export declare function removePlugin(name: string): boolean;

package/dist/plugin-store.js

@@ -0,0 +1,56 @@
+/**
+ * CRUD over the `plugins` table — the registry of installed plugins the loader
+ * imports at boot. A plugin is installed either from npm (`source: "npm"`, into
+ * `~/.rynx/plugins`) or from a local directory (`source: "local"`, loaded in
+ * place). The daemon ships with none; channel plugins are installed by the user.
+ */
+import { db } from "./db.js";
+function toRecord(row) {
+    return {
+        name: row.name,
+        spec: row.spec,
+        source: row.source,
+        version: row.version ?? undefined,
+        enabled: row.enabled !== 0,
+        installedAt: row.installed_at,
+    };
+}
+/** All installed plugins, enabled or not. */
+export function listPlugins() {
+    const rows = db().prepare("SELECT * FROM plugins ORDER BY name").all();
+    return rows.map(toRecord);
+}
+/** Only enabled plugins — the set the loader imports. */
+export function listEnabledPlugins() {
+    return listPlugins().filter((p) => p.enabled);
+}
+export function getPlugin(name) {
+    const row = db().prepare("SELECT * FROM plugins WHERE name = ?").get(name);
+    return row ? toRecord(row) : undefined;
+}
+/** Insert or replace a plugin record (idempotent install). */
+export function upsertPlugin(rec) {
+    db()
+        .prepare(`INSERT INTO plugins (name, spec, source, version, enabled, installed_at)
+       VALUES (@name, @spec, @source, @version, @enabled, @installedAt)
+       ON CONFLICT(name) DO UPDATE SET
+         spec = excluded.spec,
+         source = excluded.source,
+         version = excluded.version,
+         enabled = excluded.enabled`)
+        .run({
+        name: rec.name,
+        spec: rec.spec,
+        source: rec.source,
+        version: rec.version ?? null,
+        enabled: rec.enabled === false ? 0 : 1,
+        installedAt: new Date().toISOString(),
+    });
+}
+export function setPluginEnabled(name, enabled) {
+    db().prepare("UPDATE plugins SET enabled = ? WHERE name = ?").run(enabled ? 1 : 0, name);
+}
+/** Remove a plugin record. Returns false if it wasn't present. */
+export function removePlugin(name) {
+    return db().prepare("DELETE FROM plugins WHERE name = ?").run(name).changes > 0;
+}

package/dist/pm2.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Build a dialable control-console URL from the daemon's bind host/port. Bind-all
+ * addresses (`0.0.0.0`, `::`) aren't dialable, so show a loopback host instead.
+ */
+export declare function formatControlUrl(host: string, port: number): string;
+/**
+ * Start (or, with `force`, reload) the resident daemon. We recreate the pm2
+ * entry from scratch (delete + start) so config flags are always fresh; the
+ * `force === false` path short-circuits when it's already online.
+ */
+export declare function startDaemon({ force }: {
+    force: boolean;
+}): number;
+/** Stop and remove the daemon from pm2's process list. */
+export declare function stopDaemon(): number;
+/** Print a one-line status; exit 0 only when online. */
+export declare function statusDaemon(): number;
+/** Stream the daemon's pm2 logs until the user detaches (Ctrl-C). */
+export declare function streamLogs(): void;

package/dist/pm2.js

@@ -0,0 +1,153 @@
+/**
+ * Thin wrapper that supervises the resident daemon via pm2.
+ *
+ * We drive pm2 through its CLI binary (resolved from the installed `pm2`
+ * package) rather than its programmatic API — that keeps us free of pm2's
+ * patchy type definitions under `strict`, and `pm2 logs` streaming is awkward
+ * via the API anyway. Process config is passed inline as flags, so there is no
+ * shipped `ecosystem.cjs` to keep in sync.
+ */
+import { spawn, spawnSync } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadConfig } from "@rynx-ai/core";
+const require = createRequire(import.meta.url);
+/** pm2 app name — single resident daemon per machine. */
+const APP_NAME = "rynx";
+/**
+ * Build a dialable control-console URL from the daemon's bind host/port. Bind-all
+ * addresses (`0.0.0.0`, `::`) aren't dialable, so show a loopback host instead.
+ */
+export function formatControlUrl(host, port) {
+    const dialable = host === "0.0.0.0" || host === "::" || host.trim() === "" ? "localhost" : host;
+    return `http://${dialable}:${port}/`;
+}
+/** Resolve the URL the daemon will serve the control console at (best-effort). */
+function controlConsoleUrl() {
+    try {
+        const config = loadConfig();
+        return formatControlUrl(config.HOST, config.PORT);
+    }
+    catch {
+        return formatControlUrl("0.0.0.0", 3000); // defaults when env can't be parsed
+    }
+}
+/**
+ * Highlight the URL bold + underlined bright magenta (matching the console's
+ * purple brand) so it stands out as a link. Plain text when stdout isn't a TTY,
+ * so piped/redirected output stays free of escape codes.
+ */
+function styleUrl(url) {
+    return process.stdout.isTTY ? `\x1b[1;4;95m${url}\x1b[0m` : url;
+}
+function pm2Bin() {
+    // pm2 ships its CLI at bin/pm2; run it with our own node.
+    return require.resolve("pm2/bin/pm2");
+}
+/** `index-daemon.js` sits next to this file in `dist/`. */
+function daemonEntryPath() {
+    return join(dirname(fileURLToPath(import.meta.url)), "index-daemon.js");
+}
+function logsDir() {
+    const home = process.env.RYNX_HOME?.trim() || join(homedir(), ".rynx");
+    const dir = join(home, "logs");
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+/** Run a pm2 command inheriting stdio; returns its exit code. */
+function runPm2(args) {
+    const res = spawnSync(process.execPath, [pm2Bin(), ...args], {
+        stdio: "inherit",
+        env: process.env,
+    });
+    return res.status ?? 1;
+}
+/** Read the daemon's current pm2 record, or null if not registered. */
+function describe() {
+    const res = spawnSync(process.execPath, [pm2Bin(), "jlist"], { encoding: "utf8" });
+    if (res.status !== 0 || !res.stdout)
+        return null;
+    let list;
+    try {
+        list = JSON.parse(res.stdout);
+    }
+    catch {
+        return null;
+    }
+    return list.find((proc) => proc.name === APP_NAME) ?? null;
+}
+/**
+ * Start (or, with `force`, reload) the resident daemon. We recreate the pm2
+ * entry from scratch (delete + start) so config flags are always fresh; the
+ * `force === false` path short-circuits when it's already online.
+ */
+export function startDaemon({ force }) {
+    const existing = describe();
+    if (!force && existing?.pm2_env?.status === "online") {
+        console.log(`rynx is already running (pid ${existing.pid ?? "?"}). Use \`rynx restart\` to reload.`);
+        console.log(`Control console: ${styleUrl(controlConsoleUrl())}`);
+        return 0;
+    }
+    const dir = logsDir();
+    if (existing)
+        runPm2(["delete", APP_NAME]);
+    const status = runPm2([
+        "start",
+        daemonEntryPath(),
+        "--name",
+        APP_NAME,
+        // Resolve `.env` relative to where the user invoked `rynx start`.
+        "--cwd",
+        process.cwd(),
+        "--max-restarts",
+        "10",
+        "--restart-delay",
+        "3000",
+        "--output",
+        join(dir, "out.log"),
+        "--error",
+        join(dir, "err.log"),
+        "--merge-logs",
+        "--time",
+    ]);
+    if (status === 0) {
+        console.log(`rynx ${force ? "restarted" : "started"} (pm2 app "${APP_NAME}", logs: ${dir}).`);
+        console.log(`Control console: ${styleUrl(controlConsoleUrl())}`);
+    }
+    return status;
+}
+/** Stop and remove the daemon from pm2's process list. */
+export function stopDaemon() {
+    if (!describe()) {
+        console.log("rynx is not running.");
+        return 0;
+    }
+    const status = runPm2(["delete", APP_NAME]);
+    if (status === 0)
+        console.log("rynx stopped.");
+    return status;
+}
+/** Print a one-line status; exit 0 only when online. */
+export function statusDaemon() {
+    const app = describe();
+    if (!app) {
+        console.log("rynx: stopped (not registered with pm2)");
+        return 1;
+    }
+    const state = app.pm2_env?.status ?? "unknown";
+    const pid = app.pid ? ` pid=${app.pid}` : "";
+    const restarts = app.pm2_env?.restart_time != null ? ` restarts=${app.pm2_env.restart_time}` : "";
+    console.log(`rynx: ${state}${pid}${restarts}`);
+    return state === "online" ? 0 : 1;
+}
+/** Stream the daemon's pm2 logs until the user detaches (Ctrl-C). */
+export function streamLogs() {
+    const child = spawn(process.execPath, [pm2Bin(), "logs", APP_NAME, "--lines", "50"], {
+        stdio: "inherit",
+        env: process.env,
+    });
+    child.on("exit", (code) => process.exit(code ?? 0));
+}

package/dist/registry.d.ts

@@ -0,0 +1,23 @@
+import { type ChannelInstanceDescriptor, type ChannelTypeDescriptor, type RynxPlugin } from "@rynx-ai/core";
+import { type PluginRecord } from "./plugin-store.js";
+/** Directory npm-installed plugins live under (override via `RYNX_PLUGINS_DIR`). */
+export declare function pluginsDir(): string;
+/** All channel types currently available (from loaded plugins). */
+export declare function listChannelTypes(): ChannelTypeDescriptor[];
+export declare function getChannelType(type: string): ChannelTypeDescriptor | undefined;
+/** Absolute package directory a plugin record resolves to. */
+export declare function pluginPkgDir(rec: Pick<PluginRecord, "source" | "spec">): string;
+/** Import a package directory's `plugin` manifest export (or null if absent). */
+export declare function importPluginManifest(pkgDir: string): Promise<RynxPlugin | null>;
+/**
+ * Rebuild the channel-type catalog from the enabled plugins in the registry.
+ * Call at boot and after an install/enable/disable change. Failures to load a
+ * single plugin are warned and skipped — one bad plugin can't break the rest.
+ */
+export declare function loadPlugins(warn?: (message: string) => void): Promise<void>;
+/**
+ * Resolve every enabled instance (joined with its channel) to a mountable
+ * descriptor, binding each to the factory its channel `type` resolves to in the
+ * catalog. Unknown types (no plugin providing them) are skipped.
+ */
+export declare function resolveChannelInstances(warn?: (message: string) => void): Promise<ChannelInstanceDescriptor[]>;

package/dist/registry.js

@@ -0,0 +1,117 @@
+/**
+ * Plugin loader + channel-type catalog.
+ *
+ * There are no built-in channels: the daemon imports whatever plugins are
+ * recorded (enabled) in the `plugins` table, reads each one's `plugin` manifest,
+ * and collects the channel types they contribute into an in-memory catalog.
+ * `loadPlugins()` (re)builds the catalog from the registry; everything else
+ * reads the catalog synchronously. The installer calls `loadPlugins()` after a
+ * change so a freshly-installed plugin's types appear without a restart.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { rynxHome, } from "@rynx-ai/core";
+import { listEnabledDescriptors } from "./instance-store.js";
+import { listEnabledPlugins } from "./plugin-store.js";
+/** Directory npm-installed plugins live under (override via `RYNX_PLUGINS_DIR`). */
+export function pluginsDir() {
+    return process.env.RYNX_PLUGINS_DIR?.trim() || join(rynxHome(), "plugins");
+}
+/** type → descriptor, rebuilt by {@link loadPlugins}. */
+const catalog = new Map();
+/** All channel types currently available (from loaded plugins). */
+export function listChannelTypes() {
+    return [...catalog.values()];
+}
+export function getChannelType(type) {
+    return catalog.get(type);
+}
+/** Resolve a plugin record to the file URL of its entry module. */
+function entryUrl(pkgDir) {
+    const pkg = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf8"));
+    let rel = pkg.rynx?.plugin;
+    if (!rel) {
+        const dot = pkg.exports && typeof pkg.exports === "object" && "." in pkg.exports
+            ? pkg.exports["."]
+            : pkg.exports;
+        if (typeof dot === "string") {
+            rel = dot;
+        }
+        else if (dot && typeof dot === "object") {
+            const cond = dot;
+            rel = cond.import ?? cond.default ?? cond.require;
+        }
+        rel = rel ?? pkg.main ?? "index.js";
+    }
+    return pathToFileURL(join(pkgDir, rel)).href;
+}
+/** Absolute package directory a plugin record resolves to. */
+export function pluginPkgDir(rec) {
+    // local: spec is an absolute directory; npm: resolve under the plugins prefix.
+    return rec.source === "local" ? rec.spec : join(pluginsDir(), "node_modules", ...rec.spec.split("/"));
+}
+/** Import a package directory's `plugin` manifest export (or null if absent). */
+export async function importPluginManifest(pkgDir) {
+    const mod = (await import(entryUrl(pkgDir)));
+    const plugin = (mod.plugin ?? mod.default);
+    return plugin && typeof plugin === "object" ? plugin : null;
+}
+function importPlugin(rec) {
+    return importPluginManifest(pluginPkgDir(rec));
+}
+/**
+ * Rebuild the channel-type catalog from the enabled plugins in the registry.
+ * Call at boot and after an install/enable/disable change. Failures to load a
+ * single plugin are warned and skipped — one bad plugin can't break the rest.
+ */
+export async function loadPlugins(warn = () => { }) {
+    catalog.clear();
+    for (const rec of listEnabledPlugins()) {
+        let plugin;
+        try {
+            plugin = await importPlugin(rec);
+        }
+        catch (error) {
+            warn(`plugin "${rec.name}" failed to load: ${messageOf(error)}`);
+            continue;
+        }
+        if (!plugin) {
+            warn(`plugin "${rec.name}" has no \`plugin\` export — skipped`);
+            continue;
+        }
+        for (const channel of plugin.channels ?? []) {
+            if (catalog.has(channel.type)) {
+                warn(`channel type "${channel.type}" already provided; "${rec.name}" ignored for it`);
+                continue;
+            }
+            catalog.set(channel.type, channel);
+        }
+    }
+}
+/**
+ * Resolve every enabled instance (joined with its channel) to a mountable
+ * descriptor, binding each to the factory its channel `type` resolves to in the
+ * catalog. Unknown types (no plugin providing them) are skipped.
+ */
+export async function resolveChannelInstances(warn = () => { }) {
+    const instances = [];
+    for (const d of listEnabledDescriptors()) {
+        const descriptor = catalog.get(d.type);
+        if (!descriptor) {
+            warn(`unknown channel type "${d.type}" (instance "${d.instanceId}") — no installed plugin provides it; skipped`);
+            continue;
+        }
+        instances.push({
+            instanceId: d.instanceId,
+            type: d.type,
+            factory: descriptor.factory,
+            options: d.options,
+            agent: d.agent,
+        });
+    }
+    return instances;
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/session-log-store.d.ts

@@ -0,0 +1,22 @@
+/**
+ * SQLite-backed {@link SessionLogStore} over the daemon's `session_items` table
+ * (`~/.rynx/rynx.db`). The durable home of the canonical conversation log: an
+ * append-only stream of {@link SessionItem}s ordered by a monotonic, gap-free
+ * `position` per session. Producer
+ * identity (`id`/`createdAt`/`data`) is preserved; the store owns only the
+ * session-global `position`, assigned under a transaction so concurrent appends
+ * can't collide.
+ */
+import type { SessionItem, SessionLogStore, SessionLogSummary } from "@rynx-ai/core";
+export declare class SqliteSessionLogStore implements SessionLogStore {
+    append(sessionId: string, items: SessionItem[]): Promise<SessionItem[]>;
+    list(sessionId: string, opts?: {
+        afterId?: string;
+        limit?: number;
+    }): Promise<SessionItem[]>;
+    snapshot(sessionId: string): Promise<SessionItem[]>;
+    listSessions(opts?: {
+        limit?: number;
+    }): Promise<SessionLogSummary[]>;
+    deleteSession(sessionId: string): Promise<void>;
+}