@alisio/core 0.1.0-alpha.9 → 0.1.0

package/dist/runtime/process.js

@@ -1,4 +1,5 @@
 import { spawn, spawnSync } from "node:child_process";
+import { createWriteStream } from "node:fs";
 /**
  * Detect a spawn failure caused by a missing executable (`ENOENT`), so tools can explain how to
  * install the dependency instead of surfacing the raw OS error.
@@ -17,6 +18,37 @@ export const RIPGREP_INSTALL_HINT = "Install ripgrep (rg): `sudo apt install rip
 export function ripgrepDiagnostic(found) {
     return found ? undefined : RIPGREP_INSTALL_HINT;
 }
+/** Whether a process id belongs to a live process (EPERM still means alive). */
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code !== "ESRCH";
+    }
+}
+/**
+ * Kills a spawned process and everything it started: the process group on POSIX (children are
+ * spawned with `detached`, so the pid leads its own group) and `taskkill /T /F` on Windows.
+ * Synchronous, so it is also safe inside a `process.on("exit")` handler. Never throws.
+ */
+export function killProcessTree(pid, fallback) {
+    try {
+        if (process.platform !== "win32")
+            process.kill(-pid, "SIGKILL");
+        else
+            spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
+    }
+    catch {
+        try {
+            fallback?.();
+        }
+        catch {
+            /* already gone */
+        }
+    }
+}
 export async function runProcess(command, args, options) {
     options.signal.throwIfAborted();
     const signal = AbortSignal.any([
@@ -31,6 +63,8 @@ export async function runProcess(command, args, options) {
         detached: process.platform !== "win32",
         windowsHide: true,
     });
+    if (child.pid !== undefined)
+        options.onSpawn?.(child.pid);
     const exited = new Promise((resolveExit, reject) => {
         child.once("error", reject);
         child.once("close", (code, sig) => resolveExit(code ?? (sig ? 128 : 1)));
@@ -59,36 +93,86 @@ export async function runProcess(command, args, options) {
     const kill = () => {
         if (finished || child.pid === undefined)
             return;
-        try {
-            if (process.platform !== "win32")
-                process.kill(-child.pid, "SIGKILL");
-            else {
-                spawnSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" });
-                child.kill();
-            }
-        }
-        catch {
-            child.kill("SIGKILL");
-        }
+        killProcessTree(child.pid, () => child.kill("SIGKILL"));
+        if (process.platform === "win32")
+            child.kill();
     };
     signal.addEventListener("abort", terminate, { once: true });
     if (signal.aborted)
         terminate();
     let size = 0, truncated = false;
     const max = options.maxBytes ?? 32_000;
-    const consume = (stream) => new Promise((resolveText, reject) => {
+    const tailMode = options.onOverflow === "truncate";
+    const maxLog = options.maxLogBytes ?? 10 * 1024 * 1024;
+    const logs = [];
+    const logger = (path) => {
+        if (!path)
+            return undefined;
+        const out = createWriteStream(path, { flags: "w" });
+        out.on("error", () => {
+            /* A log write failure never fails the process run. */
+        });
+        logs.push(out);
+        let written = 0, cut = false;
+        return (chunk) => {
+            if (cut)
+                return;
+            const room = maxLog - written;
+            if (chunk.byteLength > room) {
+                out.write(chunk.subarray(0, Math.max(0, room)));
+                out.write(Buffer.from("\n[log truncated]\n"));
+                cut = true;
+                written = maxLog;
+                return;
+            }
+            out.write(chunk);
+            written += chunk.byteLength;
+        };
+    };
+    const consume = (stream, logPath) => new Promise((resolveText, reject) => {
         const decoder = new TextDecoder();
+        const log = logger(logPath);
         let text = "", done = false;
+        // Tail mode keeps raw buffers and decodes once at the end (a cut may split a character).
+        const tail = [];
+        let tailBytes = 0;
         const finish = () => {
             if (done)
                 return;
             done = true;
-            text += decoder.decode();
+            if (tailMode) {
+                const joined = Buffer.concat(tail);
+                text = new TextDecoder().decode(joined).replace(/^\uFFFD+/, "");
+            }
+            else
+                text += decoder.decode();
             resolveText(text);
         };
         stream.on("data", (value) => {
             if (done)
                 return;
+            log?.(value);
+            if (tailMode) {
+                const live = decoder.decode(value, { stream: true });
+                if (live)
+                    options.onData?.(live);
+                tail.push(value);
+                tailBytes += value.byteLength;
+                while (tailBytes > max && tail.length) {
+                    const first = tail[0];
+                    const excess = tailBytes - max;
+                    if (first.byteLength <= excess) {
+                        tail.shift();
+                        tailBytes -= first.byteLength;
+                    }
+                    else {
+                        tail[0] = first.subarray(excess);
+                        tailBytes -= excess;
+                    }
+                    truncated = true;
+                }
+                return;
+            }
             const remaining = Math.max(0, max - size), slice = value.subarray(0, remaining);
             size += slice.byteLength;
             const chunk = decoder.decode(slice, { stream: true });
@@ -107,8 +191,8 @@ export async function runProcess(command, args, options) {
     });
     try {
         const [stdout, stderr, exitCode] = await Promise.all([
-            consume(child.stdout),
-            consume(child.stderr),
+            consume(child.stdout, options.logFiles?.stdout),
+            consume(child.stderr, options.logFiles?.stderr),
             exited,
         ]);
         signal.throwIfAborted();
@@ -118,5 +202,6 @@ export async function runProcess(command, args, options) {
         signal.removeEventListener("abort", terminate);
         clearTimeout(graceTimer);
         kill();
+        await Promise.all(logs.map((out) => new Promise((resolveLog) => out.end(() => resolveLog()))));
     }
 }

package/dist/runtime/sqlite.d.ts

@@ -1,3 +1,5 @@
 import type { SqlDatabase } from "@alisio/sdk";
 export declare function isSqliteExperimentalWarning(message: string, type?: string): boolean;
+/** Opens an existing database file read-only (no directory or file is created). */
+export declare function openReadOnlyDatabase(path: string): SqlDatabase;
 export declare function openDatabase(path: string): SqlDatabase;

package/dist/runtime/sqlite.js

@@ -34,6 +34,24 @@ function sqlite() {
     return module;
 }
 const plain = (row) => row === undefined || row === null ? undefined : { ...row };
+/** Opens an existing database file read-only (no directory or file is created). */
+export function openReadOnlyDatabase(path) {
+    const db = new (sqlite().DatabaseSync)(path, { readOnly: true });
+    db.exec("PRAGMA query_only=ON;");
+    return {
+        exec: (sql) => db.exec(sql),
+        prepare(sql) {
+            const raw = db.prepare(sql);
+            return {
+                run: (...params) => raw.run(...params),
+                get: (...params) => plain(raw.get(...params)),
+                all: (...params) => raw.all(...params).map((r) => ({ ...r })),
+            };
+        },
+        transaction: (fn) => fn(),
+        close: () => db.close(),
+    };
+}
 export function openDatabase(path) {
     const memory = path === ":memory:";
     const fresh = !memory && !existsSync(path);

package/dist/runtime/store.d.ts

@@ -1,10 +1,15 @@
 import { type Message, type SqlDatabase, type ToolCall, type ToolResult } from "@alisio/sdk";
-import type { Session, SessionStore } from "../core/contracts.ts";
+import type { BeginRunInput, EndRunInput, EventPage, MessagePage, PageOptions, RunRecord, Session, SessionStore, ToolCallMeta } from "../core/contracts.ts";
 export declare class SQLiteStore implements SessionStore {
     readonly db: SqlDatabase;
     constructor(path: string);
     /** Forward-only, idempotent migrations. Existing databases keep all rows. */
     private migrate;
+    /**
+     * The root of a session (itself for roots), following `parent_id`. Unknown ids are their own
+     * root, so callers never throw on a session another process has not written yet.
+     */
+    rootOf(id: string): string;
     create(workspace: string, provider: string, model: string): Session;
     private row;
     get(id: string): Session;
@@ -23,15 +28,98 @@ export declare class SQLiteStore implements SessionStore {
     interruptStale(): number;
     messages(id: string): Message[];
     append(id: string, message: Message): void;
+    private touch;
     setModel(id: string, model: string): void;
     compact(id: string, replaced: number, summary: Message): void;
     overwrite(id: string, messages: Message[]): void;
     acquire(id: string): void;
     release(id: string): void;
-    beginCall(id: string, call: ToolCall): void;
+    beginCall(id: string, call: ToolCall, meta?: ToolCallMeta): void;
     endCall(id: string, call: ToolCall, result: ToolResult): void;
+    /**
+     * Calls of a session with one effect (for example `write`), oldest first. Needs the v4
+     * `effect`/`run_id`/`started_at` columns; rows written by older versions have no effect.
+     */
+    effectCalls(session: string, effect: string): Array<{
+        callId: string;
+        name: string;
+        runId?: string;
+        startedAt?: number;
+    }>;
+    /** Rich (ui/image) parts persist as part of the serialized result and replay verbatim. */
+    callResult(id: string, callId: string): ToolResult | undefined;
     reconcile(id: string, acknowledge?: boolean): void;
-    event(id: string, runId: string, type: string, data: unknown): void;
+    /** Persists a durable event and returns its global `events.seq`. */
+    event(id: string, runId: string, type: string, data: unknown, meta?: {
+        correlationId?: string;
+    }): number;
+    private runRow;
+    private runById;
+    beginRun(input: BeginRunInput): {
+        run: RunRecord;
+        created: boolean;
+    };
+    endRun(id: string, input: EndRunInput): void;
+    runByRequest(session: string, requestId: string): RunRecord | undefined;
+    runs(session: string, options?: {
+        limit?: number;
+    }): RunRecord[];
+    interruptRuns(): number;
+    /**
+     * A page of messages by `seq`. With `after`, the first `limit` rows after it; otherwise the
+     * newest `limit` rows (before `before` when given). Items are always in ascending order.
+     */
+    messagesPage(session: string, options?: PageOptions & {
+        compacted?: boolean;
+    }): MessagePage;
+    /** Durable events of a session after `after` (a previous `eventId`), ascending. */
+    eventsPage(session: string, options?: PageOptions): EventPage;
+    /**
+     * Known workspaces for web clients: the workspaces of root sessions plus the ones recorded with
+     * `recordWorkspace` (v4 `workspaces` table), with their UI metadata (v5: `archivedAt`) and
+     * root-session count.
+     */
+    workspaces(): Array<{
+        path: string;
+        label?: string;
+        pinned: boolean;
+        lastOpenedAt?: number;
+        archivedAt?: number;
+        sessions: number;
+    }>;
+    /**
+     * Records (upserts) a workspace and patches its UI metadata (`label: null` clears the label;
+     * `archived` stamps or clears `archived_at` and never touches its sessions).
+     */
+    recordWorkspace(path: string, patch?: {
+        label?: string | null;
+        pinned?: boolean;
+        lastOpenedAt?: number;
+        archived?: boolean;
+    }): void;
+    /**
+     * Patches web-facing session metadata: title, pin, archive flag and `options` (shallow-merged
+     * into the stored options object). Does not touch the run-relevant columns.
+     */
+    updateSessionMeta(id: string, patch: {
+        title?: string | null;
+        pinned?: boolean;
+        archived?: boolean;
+        options?: Record<string, unknown>;
+    }): void;
+    /**
+     * Atomic read-modify-write of `sessions.options` (`BEGIN IMMEDIATE`: safe across processes that
+     * share the database). `change` receives the current options and returns the keys to merge
+     * (`undefined` removes a key; `undefined` as a whole changes nothing) and a value for the caller.
+     */
+    mutateSessionOptions<T>(id: string, change: (current: Record<string, unknown>) => {
+        patch?: Record<string, unknown>;
+        value: T;
+    }): T;
+    /** `MAX(events.seq)` of a session (0 without events): the web snapshot cursor. */
+    lastEventId(session: string): number;
+    /** The pid of another live process holding the session lock, if any. */
+    lockedBy(id: string): number | undefined;
     getState(plugin: string, key: string): unknown;
     setState(plugin: string, key: string, value: unknown): void;
     close(): void;