@sigrun/sigrun 0.1.5 → 0.2.0

package/dist/harness/user-services.js

@@ -0,0 +1,391 @@
+/** Core-owned per-user service processes. Workers and services are siblings. */
+import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { resolve, sep } from "node:path";
+import { validateGrantPath } from "../sandbox/grants.js";
+/** Replay is capped so a noisy service cannot grow core memory without bound. */
+export const SERVICE_STDIO_REPLAY_BYTES = 64 * 1024;
+const SERVICE_STDIO_TRUNCATED = "[service output truncated]\n";
+class SharedServiceStream {
+    chunks = [];
+    bytes = 0;
+    truncated = false;
+    handles = 0;
+    controllers = new Set();
+    ended = false;
+    get retainedBytes() { return this.bytes; }
+    setHandles(count) {
+        this.handles = count;
+        if (count === 0) {
+            this.chunks.length = 0;
+            this.bytes = 0;
+            this.truncated = false;
+        }
+    }
+    stream() {
+        return new ReadableStream({
+            start: (controller) => {
+                if (this.truncated)
+                    controller.enqueue(new TextEncoder().encode(SERVICE_STDIO_TRUNCATED));
+                for (const chunk of this.chunks)
+                    controller.enqueue(chunk);
+                if (this.ended)
+                    controller.close();
+                else
+                    this.controllers.add(controller);
+            },
+            cancel: (reason) => {
+                for (const controller of this.controllers) {
+                    try {
+                        controller.error(reason);
+                    }
+                    catch { /* already closed */ }
+                }
+                this.controllers.clear();
+            },
+        });
+    }
+    write(chunk) {
+        if (this.ended || this.handles === 0)
+            return;
+        const copy = new Uint8Array(chunk);
+        this.chunks.push(copy);
+        this.bytes += copy.byteLength;
+        while (this.bytes > SERVICE_STDIO_REPLAY_BYTES && this.chunks.length > 0) {
+            const dropped = this.chunks.shift();
+            this.bytes -= dropped.byteLength;
+            this.truncated = true;
+        }
+        if (this.bytes > SERVICE_STDIO_REPLAY_BYTES) {
+            const last = this.chunks[this.chunks.length - 1];
+            const excess = this.bytes - SERVICE_STDIO_REPLAY_BYTES;
+            this.chunks[0] = last.subarray(excess);
+            this.bytes = SERVICE_STDIO_REPLAY_BYTES;
+            this.truncated = true;
+        }
+        for (const controller of this.controllers) {
+            try {
+                controller.enqueue(copy);
+            }
+            catch {
+                this.controllers.delete(controller);
+            }
+        }
+    }
+    end() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        for (const controller of this.controllers) {
+            try {
+                controller.close();
+            }
+            catch { /* already closed */ }
+        }
+        this.controllers.clear();
+    }
+}
+function within(path, root) {
+    return path === root || path.startsWith(root.endsWith(sep) ? root : root + sep);
+}
+function packageDirectory(entry, packageDir) {
+    if (packageDir !== undefined)
+        return realpathSync(packageDir);
+    const path = entry.startsWith("file://") ? new URL(entry) : undefined;
+    return realpathSync(path === undefined ? resolve(entry, "..") : new URL(".", path));
+}
+function tail(lines) {
+    return lines.slice(-20).join("\n");
+}
+function serviceError(entry) {
+    return new Error(`service ${entry.slug}/${entry.name} for ${entry.user} failed${entry.lastError === undefined || entry.lastError === "" ? "" : `:\n${entry.lastError}`}`);
+}
+export class UserServices {
+    deps;
+    entries = new Map();
+    declarations = new Map();
+    directories = new Map();
+    closed = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    register(slug, declarations, packageDir) {
+        this.declarations.set(slug, declarations);
+        this.directories.set(slug, packageDir);
+    }
+    /** A load/re-key failure stops everything the extension had started. */
+    quarantine(slug) {
+        this.declarations.delete(slug);
+        this.directories.delete(slug);
+        return this.stopSlug(slug);
+    }
+    /** Only a committed write to THIS user's settings for THIS slug clears its failure fence. */
+    settingsChanged(slug, user) {
+        for (const entry of this.entries.values()) {
+            if (entry.slug === slug && entry.user === user) {
+                entry.failures = [];
+                entry.lastError = undefined;
+                if (entry.live === undefined)
+                    this.entries.delete(entry.key);
+            }
+        }
+    }
+    /** Retained replay bytes, exposed for lifecycle diagnostics and tests. */
+    retainedStdioBytes(slug, name, user) {
+        const live = this.entries.get(`${slug}\0${name}\0${user}`)?.live;
+        return { stdout: live?.stdout.retainedBytes ?? 0, stderr: live?.stderrStream.retainedBytes ?? 0 };
+    }
+    statuses() {
+        return [...this.entries.values()].flatMap((entry) => {
+            const live = entry.live;
+            const failed = live === undefined && entry.failures.length >= 3;
+            // A starting process is not failed, and one/two crashes are
+            // retryable rather than a persistent failed service. Do not expose
+            // a stale entry in either case; the next connect owns the restart.
+            if (live === undefined && !failed)
+                return [];
+            return [{
+                    slug: entry.slug,
+                    name: entry.name,
+                    user: entry.user,
+                    state: failed ? "failed" : live.handles === 0 ? "idle" : "running",
+                    ...(failed && entry.lastError !== undefined ? { lastError: entry.lastError } : {}),
+                }];
+        });
+    }
+    async connect(slug, name, user, ctx = { abortSignal: undefined }) {
+        if (this.closed)
+            throw new Error("user services are stopped");
+        const declaration = this.declarations.get(slug)?.find((candidate) => candidate.name === name);
+        if (declaration === undefined)
+            throw new Error(`unknown service "${slug}/${name}"`);
+        const key = `${slug}\0${name}\0${user}`;
+        let entry = this.entries.get(key);
+        if (entry === undefined) {
+            entry = {
+                key, slug, name, user, declaration,
+                packageDir: this.directories.get(slug),
+                failures: [],
+                terminal: false,
+            };
+            // Failed entries stay in the map across explicit stops, so this new
+            // entry is used only when there is no crash history to preserve.
+            this.entries.set(key, entry);
+        }
+        if (entry.live === undefined && entry.failures.length >= 3)
+            throw serviceError(entry);
+        if (entry.live !== undefined)
+            return this.attach(entry);
+        if (entry.starting === undefined) {
+            const starting = this.start(entry, ctx);
+            entry.starting = starting;
+            void starting.finally(() => {
+                if (entry?.starting === starting)
+                    entry.starting = undefined;
+            }).catch(() => { });
+        }
+        await entry.starting;
+        return this.attach(entry);
+    }
+    async start(entry, ctx) {
+        const spec = await entry.declaration.start(entry.user, ctx);
+        if (spec === undefined) {
+            this.entries.delete(entry.key);
+            throw new Error("service not available for this user");
+        }
+        const base = this.deps.policyFor(entry.user);
+        if ("reason" in base)
+            throw new Error(base.reason);
+        let launchPolicy = base;
+        if (this.deps.isolationActive()) {
+            const readPaths = [entry.packageDir];
+            if (this.deps.managed !== undefined) {
+                for (const path of spec.readPaths ?? []) {
+                    const real = realpathSync(path);
+                    if (!within(real, entry.packageDir)) {
+                        const result = validateGrantPath(path, { managed: this.deps.managed, user: entry.user });
+                        if (!result.ok)
+                            throw new Error(`${path}: ${result.reason}`);
+                        readPaths.push(result.realpath);
+                    }
+                }
+            }
+            else {
+                readPaths.push(...(spec.readPaths ?? []));
+            }
+            launchPolicy = { ...base, ro: [...new Set([...base.ro, ...readPaths])].sort() };
+        }
+        const env = { ...base.env, ...spec.env };
+        delete env.SSH_AUTH_SOCK;
+        const active = this.deps.isolationActive();
+        const launch = active
+            ? this.deps.launch(launchPolicy, spec.command, spec.args, env)
+            : { command: spec.command, args: [...spec.args], env };
+        const child = spawn(launch.command, launch.args, {
+            env: launch.env,
+            cwd: spec.cwd ?? base.home,
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        entry.live = this.observe(entry, child);
+    }
+    observe(entry, child) {
+        const live = {
+            child,
+            handles: 0,
+            lastTraffic: this.deps.now(),
+            stderr: [],
+            stdout: new SharedServiceStream(),
+            stderrStream: new SharedServiceStream(),
+            terminal: false,
+            exited: Promise.resolve({ code: null, signal: null }),
+        };
+        const traffic = () => {
+            live.lastTraffic = this.deps.now();
+            this.armIdle(entry);
+        };
+        child.stdout.on("data", (chunk) => {
+            live.stdout.write(new Uint8Array(chunk));
+            traffic();
+        });
+        let pendingStderr = "";
+        child.stderr.on("data", (chunk) => {
+            live.stderrStream.write(new Uint8Array(chunk));
+            traffic();
+            pendingStderr += chunk.toString();
+            const lines = pendingStderr.split("\n");
+            pendingStderr = lines.pop() ?? "";
+            live.stderr.push(...lines.filter((line) => line !== ""));
+            if (live.stderr.length > 20)
+                live.stderr.splice(0, live.stderr.length - 20);
+        });
+        let settle;
+        const terminal = (exit, spawnError) => {
+            if (live.terminal)
+                return;
+            live.terminal = true;
+            if (spawnError !== undefined)
+                live.stderr.push(spawnError.message);
+            live.stdout.end();
+            live.stderrStream.end();
+            if (pendingStderr !== "")
+                live.stderr.push(pendingStderr);
+            if (live.stderr.length > 20)
+                live.stderr.splice(0, live.stderr.length - 20);
+            if (entry.live === live) {
+                entry.live = undefined;
+                clearTimeout(live.timer);
+                const stopped = this.closed || !this.declarations.has(entry.slug);
+                if (!stopped) {
+                    const now = this.deps.now();
+                    entry.failures = entry.failures.filter((at) => now - at <= 300_000);
+                    entry.failures.push(now);
+                    entry.lastError = tail(live.stderr);
+                }
+            }
+            settle?.(exit);
+        };
+        child.once("error", (error) => terminal({ code: null, signal: null }, error));
+        child.once("exit", (code, signal) => terminal({ code, signal }));
+        live.exited = new Promise((resolveExit) => { settle = resolveExit; });
+        return live;
+    }
+    attach(entry) {
+        const live = entry.live;
+        if (live === undefined)
+            throw serviceError(entry);
+        live.handles++;
+        live.stdout.setHandles(live.handles);
+        live.stderrStream.setHandles(live.handles);
+        clearTimeout(live.timer);
+        live.lastTraffic = this.deps.now();
+        let released = false;
+        return {
+            stdin: new WritableStream({
+                write: (chunk) => new Promise((resolveWrite, rejectWrite) => {
+                    live.lastTraffic = this.deps.now();
+                    this.armIdle(entry);
+                    live.child.stdin.write(chunk, (error) => {
+                        if (error)
+                            rejectWrite(error);
+                        else
+                            resolveWrite();
+                    });
+                }),
+                close: async () => { live.child.stdin.end(); },
+                abort: async (reason) => { live.child.stdin.destroy(reason); },
+            }),
+            stdout: live.stdout.stream(),
+            stderr: live.stderrStream.stream(),
+            exited: live.exited,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                live.handles--;
+                live.stdout.setHandles(live.handles);
+                live.stderrStream.setHandles(live.handles);
+                this.armIdle(entry);
+            },
+        };
+    }
+    armIdle(entry) {
+        const live = entry.live;
+        if (live === undefined)
+            return;
+        clearTimeout(live.timer);
+        if (live.handles > 0)
+            return;
+        const minutes = entry.declaration.idleMinutes ?? 10;
+        if (!(minutes > 0))
+            return;
+        const remaining = Math.max(0, minutes * 60_000 - (this.deps.now() - live.lastTraffic));
+        live.timer = setTimeout(() => {
+            if (entry.live === live && live.handles === 0 && this.deps.now() - live.lastTraffic >= minutes * 60_000) {
+                void this.stopEntry(entry);
+            }
+            else {
+                this.armIdle(entry);
+            }
+        }, remaining);
+        live.timer.unref();
+    }
+    async stopEntry(entry) {
+        clearTimeout(entry.live?.timer);
+        const starting = entry.starting;
+        if (starting !== undefined)
+            await starting.catch(() => { });
+        const live = entry.live;
+        entry.live = undefined;
+        if (entry.failures.length < 3)
+            this.entries.delete(entry.key);
+        if (live === undefined)
+            return;
+        await new Promise((resolveStop) => {
+            if (live.terminal || live.child.exitCode !== null || live.child.signalCode !== null) {
+                resolveStop();
+                return;
+            }
+            const timer = setTimeout(() => live.child.kill("SIGKILL"), 2_000);
+            timer.unref();
+            live.child.once("exit", () => {
+                clearTimeout(timer);
+                resolveStop();
+            });
+            live.child.kill("SIGTERM");
+        });
+    }
+    async stopUser(user) {
+        await Promise.all([...this.entries.values()].filter((entry) => entry.user === user).map((entry) => this.stopEntry(entry)));
+    }
+    async stopSlug(slug) {
+        await Promise.all([...this.entries.values()].filter((entry) => entry.slug === slug).map((entry) => this.stopEntry(entry)));
+    }
+    async stopAll() {
+        this.closed = true;
+        await Promise.all([...this.entries.values()].map((entry) => this.stopEntry(entry)));
+    }
+}
+export function servicePackageDirectory(entry, packageDir) {
+    return packageDirectory(entry, packageDir);
+}

package/dist/harness/user-tools.js

@@ -0,0 +1,187 @@
+/**
+ * Multi-user M2 Task 3: per-user extension entries and owner-driven
+ * selection.
+ *
+ * A per-user entry is an ordinary pi-durable Extension named
+ * `<slug>@<user>`. It is deliberately NOT part of the host default
+ * selection: create/fork/owner-transfer commits add the caller's entries.
+ * A late install resolves by name on the next agent read, so no stored
+ * selection needs to be edited at publish time.
+ *
+ * SELECTION IS NOT ENFORCEMENT. Every published tool is wrapped, and the
+ * wrapper reads the conversation's COMMITTED SessionMeta owner on every
+ * execution. A hand-written array selection can select another user's
+ * extension (including its hooks); it still cannot execute its tools.
+ */
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { AgentDoc, } from "@earendil-works/pi-durable";
+import { SessionMetaDoc } from "../server/session-meta.js";
+/** The registry name for one extension's publication to one user. */
+export function userEntryName(slug, user) {
+    return `${slug}@${user}`;
+}
+/** Per-user names are core-computed and never operator-authored. */
+export function isUserEntryName(name) {
+    return name.includes("@");
+}
+/** Parse a per-user name into its extension slug and owning user. */
+export function parseUserEntryName(name) {
+    const at = name.indexOf("@");
+    if (at <= 0 || at === name.length - 1)
+        return undefined;
+    return { slug: name.slice(0, at), user: name.slice(at + 1) };
+}
+/**
+ * Publish per-user tools over pi-durable's application-owned Registry.
+ * `install` replaces the same name in place; an empty tool list removes
+ * the entry altogether. Core owns the per-user slug set (the loader's
+ * declarations), not the publishing extension.
+ */
+export class UserToolRegistry {
+    registry;
+    perUserSlugs;
+    constructor(registry, perUserSlugs) {
+        this.registry = registry;
+        this.perUserSlugs = perUserSlugs;
+    }
+    set(slug, user, tools) {
+        if (!this.perUserSlugs().includes(slug)) {
+            throw new Error(`perUserTools not declared: ${slug}`);
+        }
+        const name = userEntryName(slug, user);
+        if (tools.length === 0) {
+            const installed = this.registry.snapshot().extension(name);
+            if (installed !== undefined)
+                this.registry.uninstall(installed);
+            return;
+        }
+        const extension = {
+            name,
+            tools: tools.map((tool) => this.wrap(tool, user)),
+        };
+        this.registry.install(extension);
+    }
+    removeUser(user) {
+        for (const installed of this.registry.snapshot().installed()) {
+            if (parseUserEntryName(installed.name)?.user === user) {
+                this.registry.uninstall(installed);
+            }
+        }
+    }
+    removeSlug(slug) {
+        for (const installed of this.registry.snapshot().installed()) {
+            if (parseUserEntryName(installed.name)?.slug === slug) {
+                this.registry.uninstall(installed);
+            }
+        }
+    }
+    wrap(tool, user) {
+        return {
+            ...tool,
+            execute: async (args, api, context) => {
+                const meta = await api.snapshot(SessionMetaDoc, api.conversationId, context);
+                if (meta?.owner !== user) {
+                    return {
+                        output: [
+                            { type: "text", text: "This tool belongs to another user." },
+                        ],
+                        isError: true,
+                    };
+                }
+                return tool.execute(args, api, context);
+            },
+        };
+    }
+}
+/** Remove every per-user entry belonging to `from` from a name list. */
+function withoutOldOwner(names, from) {
+    if (from === undefined)
+        return [...names];
+    const suffix = `@${from}`;
+    return names.filter((name) => !name.endsWith(suffix));
+}
+/**
+ * Rewrite the stored extension selection alongside an owner write.
+ *
+ * Object/absent selections edit the host default: remove the old owner's
+ * entries and add the new owner's declared entries. ARRAY selections are
+ * exact: they lose every old-owner name and gain NOTHING. `to: undefined`
+ * removes old entries without adding any (ownerless create/stamp paths).
+ */
+export async function rewriteSelection(tx, conversationId, from, to, perUserSlugs) {
+    // Re-stamping/forking for the SAME owner is a true no-op: arrays are
+    // exact and object edits must not drop then duplicate-check away the
+    // owner's existing entries.
+    if (from !== undefined && from === to)
+        return;
+    const agent = await tx.doc(AgentDoc, conversationId);
+    const stored = agent.extensions;
+    const additions = to === undefined ? [] : perUserSlugs.map((slug) => userEntryName(slug, to));
+    if (Array.isArray(stored)) {
+        const next = withoutOldOwner(stored, from);
+        if (next.length !== stored.length)
+            agent.extensions = next;
+        return;
+    }
+    const add = [
+        ...withoutOldOwner(stored?.add ?? [], from),
+        ...additions.filter((name) => !(stored?.add ?? []).includes(name)),
+    ];
+    const nextRemove = withoutOldOwner(stored?.remove ?? [], from).filter((name) => !additions.includes(name));
+    if (stored === undefined && additions.length === 0)
+        return;
+    agent.extensions = {
+        add,
+        ...(nextRemove.length === 0 ? {} : { remove: nextRemove }),
+    };
+}
+/** Page size for the boot's durable conversation scan. */
+const USER_SWEEP_PAGE_SIZE = 1_000;
+/**
+ * Boot reconciliation over durable conversations. Only conversations whose
+ * SessionMeta owner exists and whose Agent selection is object/absent are
+ * considered. Exact arrays remain exact. The returned count is the number
+ * of conversation commits actually needed; a second boot must report zero.
+ */
+export async function sweepUserSelections(harness, storage, perUserSlugs) {
+    if (perUserSlugs.length === 0)
+        return { scanned: 0, changed: 0 };
+    let scanned = 0;
+    let changed = 0;
+    let cursor;
+    do {
+        const page = await storage.scanConversations({ order: "ascending" }, USER_SWEEP_PAGE_SIZE, cursor, BACKGROUND_CONTEXT);
+        for (const record of page.items) {
+            scanned += 1;
+            const meta = await harness.snapshot(SessionMetaDoc, record.id, BACKGROUND_CONTEXT);
+            if (meta?.owner === undefined)
+                continue;
+            const agent = await harness.snapshot(AgentDoc, record.id, BACKGROUND_CONTEXT);
+            if (Array.isArray(agent?.extensions))
+                continue;
+            const selected = agent?.extensions?.add ?? [];
+            const owner = meta.owner;
+            const wanted = perUserSlugs.map((slug) => userEntryName(slug, owner));
+            if (wanted.every((name) => selected.includes(name)))
+                continue;
+            const conversation = await harness.conversation(record.id, BACKGROUND_CONTEXT);
+            if (conversation === undefined)
+                continue;
+            await conversation.commit(async (tx) => {
+                const draft = await tx.doc(SessionMetaDoc, record.id);
+                if (draft.owner === undefined)
+                    return;
+                await addOwnerSelection(tx, record.id, draft.owner, perUserSlugs);
+            }, BACKGROUND_CONTEXT);
+            changed += 1;
+        }
+        cursor = page.next;
+    } while (cursor !== undefined);
+    return { scanned, changed };
+}
+/** Add the current owner's declared entries to a default-edited selection. */
+export async function addOwnerSelection(tx, conversationId, owner, perUserSlugs) {
+    if (owner === undefined)
+        return;
+    await rewriteSelection(tx, conversationId, undefined, owner, perUserSlugs);
+}