super-dsh 0.1.0 → 0.1.2

package/agent-omp/dist/sdk-client.js

@@ -0,0 +1,378 @@
+import { OmpSdkSidecar } from "./sidecar-client.js";
+import { OMP_HOME } from "./knobs.js";
+/**
+ * Parse the CLI args the RPC line passed to `omp --mode rpc`. Only the subset
+ * the bridge actually uses is understood; unknown flags fail loudly rather
+ * than being silently dropped.
+ */
+function parseSpawnArgs(args) {
+    const out = {};
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--approval-mode" && args[i + 1] !== undefined) {
+            out.approvalMode = args[++i];
+        }
+        else if (args[i] === "--resume" && args[i + 1] !== undefined) {
+            out.resumeFile = args[++i];
+        }
+        else {
+            throw new Error(`OmpSdkClient: unsupported spawn arg "${args[i]}" (SDK line)`);
+        }
+    }
+    return out;
+}
+/** Response-shape shim so RpcResponse-typed call sites keep compiling. */
+function ok(command) {
+    return { type: "response", command, success: true };
+}
+// ---------------------------------------------------------------------------
+// Shared sidecar (module-level singleton, refcounted)
+// ---------------------------------------------------------------------------
+let shared = null;
+let sharedStart = null;
+let refcount = 0;
+/**
+ * Acquire the process-wide shared sidecar (one per world root, refcounted).
+ *
+ * Exactly ONE construction per acquire cycle: a leaked merge once left a
+ * duplicate pair here, so every acquire started a second child with `OMP_HOME`
+ * unset and abandoned the first (started, unreferenced, never stopped) — 350
+ * live processes down the line. Whatever else changes, this block must build
+ * the child at most once and must pin the app home on it.
+ */
+function acquire() {
+    if (shared === null) {
+        shared = new OmpSdkSidecar({ env: { OMP_HOME } });
+        sharedStart = shared.start().then(() => undefined);
+    }
+    refcount++;
+    return shared;
+}
+function release() {
+    refcount = Math.max(0, refcount - 1);
+    if (refcount === 0 && shared !== null) {
+        const dying = shared;
+        shared = null;
+        sharedStart = null;
+        void dying.stop();
+    }
+}
+/** Whether the shared sidecar exists right now (someone holds/wants it). */
+export function isSharedSidecarLive() {
+    return shared !== null;
+}
+/**
+ * Run one bridge-level call ONLY when the shared sidecar is already alive
+ * (a live session or an in-flight on-demand op holds it). Cold → `undefined`
+ * with ZERO processes: this is the periodic path's entry (model-catalog
+ * refresh) so the reconcile tick can never conjure a sidecar.
+ */
+export async function callSharedIfLive(method, params) {
+    if (shared === null)
+        return undefined;
+    const sidecar = acquire();
+    try {
+        await sharedStart;
+        return await sidecar.call(method, params);
+    }
+    finally {
+        release();
+    }
+}
+/**
+ * Run one bridge-level (non-session) data-plane call on the shared sidecar:
+ * acquire the refcounted singleton, await startup, call `method`, then release.
+ * Used by `omp-cli.ts` for `models.list` and `settings.modelRoles.get/set` so
+ * those paths share the SAME sidecar process as live sessions — never a second
+ * one. Fails with a rejection when the sidecar cannot start or the method
+ * throws; callers translate that into `undefined`/`false` (fail-soft).
+ */
+export async function callShared(method, params) {
+    const sidecar = acquire();
+    try {
+        await sharedStart;
+        return await sidecar.call(method, params);
+    }
+    finally {
+        release();
+    }
+}
+/** Discover OMP skills for a workspace (fail-soft: [] on sidecar error). */
+export async function listSkills(cwd) {
+    try {
+        const data = await callShared("skills.list", { cwd });
+        return data?.skills ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Discover OMP slash commands for a workspace (fail-soft: [] on sidecar error). */
+export async function listSlashCommands(cwd) {
+    try {
+        const data = await callShared("slashCommands.list", { cwd });
+        return data?.commands ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+export class OmpSdkClient {
+    #sidecar;
+    #handle;
+    #listeners = new Set();
+    #titleListeners = new Set();
+    #failureListeners = new Set();
+    #closed = false;
+    #failure = null;
+    #unsub;
+    constructor(sidecar, handle) {
+        this.#sidecar = sidecar;
+        this.#handle = handle;
+        this.#unsub = sidecar.onEvent((frame) => {
+            if (frame.sessionId !== this.#handle)
+                return;
+            // OMP's own session title (session file `title` entry, `source: "auto"`).
+            // It is not part of the session event stream, so the sidecar sends it on a
+            // dedicated frame; Dash never generates a title for an OMP session.
+            if (frame.event === "session:title") {
+                const title = frame.payload?.title;
+                if (typeof title !== "string")
+                    return;
+                for (const listener of [...this.#titleListeners]) {
+                    try {
+                        listener(title);
+                    }
+                    catch (error) {
+                        process.stderr.write(`omp sdk title listener error: ${String(error)}\n`);
+                    }
+                }
+                return;
+            }
+            const event = frame.payload;
+            if (event === null || typeof event !== "object" || typeof event.type !== "string")
+                return;
+            for (const listener of [...this.#listeners]) {
+                try {
+                    listener(event);
+                }
+                catch (error) {
+                    process.stderr.write(`omp sdk listener error: ${String(error)}\n`);
+                }
+            }
+        });
+    }
+    /**
+     * Start a session on the shared sidecar and resolve once it is ready.
+     * Mirrors `OmpRpcClient.spawn(args, cwd)`.
+     */
+    static async spawn(args = [], cwd) {
+        const { approvalMode, resumeFile } = parseSpawnArgs(args);
+        const sidecar = acquire();
+        try {
+            await sharedStart;
+            const created = await sidecar.call("session.create", {
+                cwd,
+                persistence: "file",
+                ...(approvalMode === undefined ? {} : { approvalMode }),
+                ...(resumeFile === undefined ? {} : { resumeFile }),
+            });
+            return new OmpSdkClient(sidecar, created.handle);
+        }
+        catch (error) {
+            release();
+            throw error;
+        }
+    }
+    /** Register an OMP session-title listener; returns the unsubscriber. */
+    onTitle(listener) {
+        this.#titleListeners.add(listener);
+        return () => {
+            this.#titleListeners.delete(listener);
+        };
+    }
+    /** Register an OMP event listener; returns the unsubscriber. */
+    on(listener) {
+        this.#listeners.add(listener);
+        return () => {
+            this.#listeners.delete(listener);
+        };
+    }
+    /** Register a failure listener; returns the unsubscriber. */
+    onFailure(listener) {
+        this.#failureListeners.add(listener);
+        return () => {
+            this.#failureListeners.delete(listener);
+        };
+    }
+    /**
+     * Raw-command escape hatch. The SDK line has no stdio command channel, so
+     * the RPC-specific `extension_ui_response` (approval-card answers) is
+     * accepted and logged — approval flows route through SDK-side approval
+     * events instead (parity work item, see README).
+     */
+    sendRaw(command) {
+        if (this.#failure !== null || this.#closed)
+            return;
+        if (process.env.OMP_TRACE === "1") {
+            process.stderr.write(`[omp-sdk] sendRaw (no-op on SDK line): ${JSON.stringify(command).slice(0, 160)}\n`);
+        }
+    }
+    /**
+     * Generic command sender for compatibility. The RPC line's free-form
+     * command channel does not exist here; supported commands are mapped onto
+     * sidecar methods, everything else fails loudly.
+     */
+    async send(command) {
+        switch (command.type) {
+            case "prompt":
+                await this.prompt(String(command.message));
+                return ok("prompt");
+            case "steer":
+                await this.steer(String(command.message));
+                return ok("steer");
+            case "follow_up":
+                await this.followUp(String(command.message));
+                return ok("follow_up");
+            case "abort":
+                await this.abort();
+                return ok("abort");
+            case "set_model":
+                await this.setModel(String(command.provider), String(command.modelId));
+                return ok("set_model");
+            case "new_session":
+                await this.newSession();
+                return ok("new_session");
+            case "get_state":
+                return { type: "response", command: "get_state", success: true, data: await this.getState() };
+            case "get_messages":
+                return { type: "response", command: "get_messages", success: true, data: { messages: await this.getMessages() } };
+            default:
+                throw new Error(`OmpSdkClient.send: unsupported command "${String(command.type)}" (SDK line)`);
+        }
+    }
+    /** Query session state; returns the `get_state`-shaped payload. */
+    async getState() {
+        const state = await this.#call("session.state");
+        return state ?? { isStreaming: false };
+    }
+    /** Query the full conversation. */
+    async getMessages() {
+        const data = await this.#call("session.messages");
+        return data?.messages ?? [];
+    }
+    /** Live token/context/cost accounting (live sessions only). */
+    async getSessionStats() {
+        return (await this.#call("session.stats")) ?? {};
+    }
+    /** Live subagent registry (fail-soft: [] until the SDK exposes it). */
+    async getSubagents() {
+        try {
+            const data = await this.#call("session.subagents");
+            return data?.subagents ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Render the live session's full base system prompt (fail-soft). */
+    async getSystemPrompt() {
+        try {
+            const data = await this.#call("session.systemPrompt");
+            return data?.systemPrompt ?? undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Start a turn with a user prompt (fire-and-forget acceptance). */
+    async prompt(message) {
+        await this.#call("session.prompt", { text: message });
+        return ok("prompt");
+    }
+    /** Queue a follow-up on a busy session. */
+    async followUp(message) {
+        await this.#call("session.followUp", { text: message });
+        return ok("follow_up");
+    }
+    /** Steer an in-flight turn. */
+    async steer(message) {
+        await this.#call("session.steer", { text: message });
+        return ok("steer");
+    }
+    /** Select the active model by provider + model id. */
+    async setModel(provider, modelId) {
+        await this.#call("session.setModel", { provider, modelId });
+        return ok("set_model");
+    }
+    /** Abort the current streaming run. */
+    async abort() {
+        await this.#call("session.abort");
+        return ok("abort");
+    }
+    /**
+     * Run OMP's own context compaction on the live session (the TUI /compact
+     * handler's exact call). Resolves when the compaction settles.
+     */
+    async compact(instructions) {
+        await this.#call("session.compact", instructions === undefined ? {} : { instructions });
+        return ok("compact");
+    }
+    /** Context-usage snapshot for pre/post compact metering (fail-soft). */
+    async contextUsage() {
+        try {
+            const data = await this.#call("session.contextUsage");
+            return data?.usage ?? undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Discard the current conversation and start a fresh session (same handle). */
+    async newSession() {
+        await this.#call("session.new");
+        return ok("new_session");
+    }
+    /**
+     * Lazy-surface parity: a real client is born live, so "ensure started" is a
+     * no-op (LazyOmpRpc implements the real deferred spawn behind the same
+     * OmpAgentRpc interface).
+     */
+    ensureStarted() {
+        return Promise.resolve();
+    }
+    /** Always true for a real client (see OmpAgentRpc.spawned). */
+    get spawned() {
+        return true;
+    }
+    /** Discard the current conversation and start a fresh session (same handle). */
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#unsub();
+        void this.#sidecar.call("session.dispose", { handle: this.#handle }).catch(() => { });
+        release();
+        this.#fail(new Error("omp sdk client closed"));
+    }
+    #call(method, params) {
+        if (this.#failure !== null)
+            return Promise.reject(this.#failure);
+        if (this.#closed)
+            return Promise.reject(new Error("omp sdk client is closed"));
+        return this.#sidecar.call(method, { handle: this.#handle, ...params });
+    }
+    #fail(error) {
+        if (this.#failure !== null)
+            return;
+        this.#failure = error;
+        for (const listener of [...this.#failureListeners]) {
+            try {
+                listener(error);
+            }
+            catch (listenerError) {
+                process.stderr.write(`omp sdk failure listener error: ${String(listenerError)}\n`);
+            }
+        }
+    }
+}

package/agent-omp/dist/sidecar-client.js

@@ -0,0 +1,195 @@
+/**
+ * Node-side client for the omp-web bun sidecar.
+ * Spawns `bun run sidecar/main.ts`, speaks the v0 JSON-lines protocol,
+ * correlates requests by id and dispatches pushed event frames.
+ */
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { PROTOCOL_VERSION, } from "./protocol.js";
+const require = createRequire(import.meta.url);
+const pkgDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+/**
+ * Locate the bun binary for the sidecar spawn.
+ *
+ * Layout-dependent: a checkout has it at `<pkg>/node_modules/.bin/bun`, but a
+ * pnpm-hoisted profile install (prod) puts binaries in the profile root's
+ * `node_modules/.bin` with the package itself symlinked under
+ * `node_modules/<name>` — so walk the ancestors' .bin directories, and fall
+ * back to a plain `bun` on PATH.
+ */
+function resolveBunBinary(fromDir) {
+    const local = path.join(fromDir, "node_modules", ".bin", "bun");
+    if (existsSync(local))
+        return local;
+    let dir = fromDir;
+    for (let i = 0; i < 8; i++) {
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+        const candidate = path.join(dir, "node_modules", ".bin", "bun");
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return "bun";
+}
+export class OmpSdkSidecar {
+    options;
+    proc = null;
+    nextId = 1;
+    pending = new Map();
+    eventHandlers = new Set();
+    readyPromise = null;
+    buffer = "";
+    startError = null;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    get started() {
+        return this.proc !== null;
+    }
+    onEvent(handler) {
+        this.eventHandlers.add(handler);
+        return () => this.eventHandlers.delete(handler);
+    }
+    async start() {
+        if (this.readyPromise)
+            return this.readyPromise;
+        this.readyPromise = new Promise((resolve, reject) => {
+            const bunBin = resolveBunBinary(pkgDir);
+            const sidecarEntry = path.join(pkgDir, "sidecar", "main.ts");
+            const env = {
+                ...process.env,
+                ...this.options.env,
+            };
+            let proc;
+            try {
+                proc = spawn(bunBin, ["run", sidecarEntry], {
+                    cwd: this.options.cwd ?? pkgDir,
+                    env,
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+            }
+            catch (err) {
+                reject(new Error(`failed to spawn bun sidecar: ${err.message}`));
+                return;
+            }
+            this.proc = proc;
+            const timeout = setTimeout(() => reject(new Error(`sidecar ready timeout (60s): ${this.startError ?? "no output"}`)), 60_000);
+            const settle = (fn) => { clearTimeout(timeout); fn(); };
+            // A dead sidecar surfaces as EPIPE on stdin writes; keep a permanent
+            // no-op error sink so no window exists where the stream throws out of the
+            // event loop (per-call degradation is handled by #writeSafe).
+            proc.stdin.on("error", () => { });
+            proc.stdout.setEncoding("utf8");
+            proc.stdout.on("data", (chunk) => this.consume(chunk, (r) => settle(() => resolve(r))));
+            proc.stderr.setEncoding("utf8");
+            proc.stderr.on("data", (chunk) => {
+                this.startError = (this.startError ?? "") + chunk;
+                process.stderr.write(`[omp-sdk-sidecar] ${chunk}`);
+            });
+            proc.on("exit", (code, signal) => {
+                settle(() => reject(new Error(`sidecar exited before ready (${code ?? signal}): ${this.startError ?? ""}`)));
+                for (const [, p] of this.pending)
+                    p.reject(new Error(`sidecar exited (${code ?? signal})`));
+                this.pending.clear();
+                this.proc = null;
+            });
+        });
+        return this.readyPromise;
+    }
+    consume(chunk, onReady) {
+        this.buffer += chunk;
+        let nl;
+        while ((nl = this.buffer.indexOf("\n")) >= 0) {
+            const raw = this.buffer.slice(0, nl).trim();
+            this.buffer = this.buffer.slice(nl + 1);
+            if (!raw)
+                continue;
+            let frame;
+            try {
+                frame = JSON.parse(raw);
+            }
+            catch {
+                continue;
+            }
+            if (frame.event === "ready") {
+                onReady?.({ protocol: frame.payload?.protocol ?? PROTOCOL_VERSION });
+                continue;
+            }
+            if (typeof frame.id === "number" && ("ok" in frame)) {
+                const p = this.pending.get(frame.id);
+                if (p) {
+                    this.pending.delete(frame.id);
+                    if (frame.ok)
+                        p.resolve(frame.result);
+                    else
+                        p.reject(new Error(frame.error));
+                }
+                continue;
+            }
+            if (frame.event) {
+                for (const h of this.eventHandlers)
+                    h(frame);
+            }
+        }
+    }
+    call(method, params) {
+        if (!this.proc?.stdin)
+            return Promise.reject(new Error("sidecar not started"));
+        const id = this.nextId++;
+        const frame = { id, method, params };
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.#writeSafe(JSON.stringify(frame) + "\n", () => {
+                this.pending.delete(id);
+                reject(new Error(`sidecar write failed: ${method}`));
+            });
+        });
+    }
+    /** Write to the sidecar's stdin without ever throwing EPIPE out of the loop. */
+    #writeSafe(chunk, onLost) {
+        const stdin = this.proc?.stdin;
+        if (!stdin)
+            return onLost();
+        const fail = (err) => {
+            // EPIPE/ECONNRESET when the sidecar died between checks — a lost frame
+            // must degrade the caller, never crash the host process.
+            stdin.removeListener("error", fail);
+            try {
+                stdin.destroy();
+            }
+            catch { /* already gone */ }
+            onLost();
+        };
+        stdin.once("error", fail);
+        try {
+            stdin.write(chunk, () => stdin.removeListener("error", fail));
+        }
+        catch {
+            fail(new Error("write threw"));
+        }
+    }
+    notify(method, params) {
+        if (!this.proc?.stdin)
+            return;
+        this.#writeSafe(JSON.stringify({ method, params }) + "\n", () => { });
+    }
+    async stop() {
+        const proc = this.proc;
+        if (!proc)
+            return;
+        this.proc = null;
+        await new Promise((resolve) => {
+            proc.once("exit", () => resolve());
+            proc.stdin.end();
+            setTimeout(() => {
+                proc.kill("SIGTERM");
+                setTimeout(() => proc.kill("SIGKILL"), 3000);
+            }, 3000).unref?.();
+        });
+    }
+}

package/agent-omp/dist/store/adapter.js

@@ -0,0 +1,47 @@
+/**
+ * SQLite driver adapter — one thin interface over whichever builtin the
+ * runtime ships. Bun → `bun:sqlite`; Node (≥22.5) → `node:sqlite`. The store
+ * never cares which: it sees exec / prepare→(run|get|all) / close.
+ *
+ * Both builtins load through `createRequire` (never a static ESM import) so
+ * neither `bun:` nor `node:sqlite` is resolved at module load: under Node the
+ * `bun:` branch is dead code, under Bun the `node:sqlite` branch is dead code.
+ */
+import { createRequire } from "node:module";
+const nodeRequire = createRequire(import.meta.url);
+function openNode(path) {
+    const { DatabaseSync: Driver } = nodeRequire("node:sqlite");
+    const db = new Driver(path);
+    return {
+        exec: (sql) => db.exec(sql),
+        prepare: (sql) => {
+            const statement = db.prepare(sql);
+            return {
+                run: (...params) => statement.run(...params),
+                get: (...params) => statement.get(...params),
+                all: (...params) => statement.all(...params),
+            };
+        },
+        close: () => db.close(),
+    };
+}
+function openBun(path) {
+    const { Database: Driver } = nodeRequire("bun:sqlite");
+    const db = new Driver(path, { create: true });
+    return {
+        exec: (sql) => db.exec(sql),
+        prepare: (sql) => {
+            const query = db.query(sql);
+            return {
+                run: (...params) => query.run(...params),
+                get: (...params) => query.get(...params),
+                all: (...params) => query.all(...params),
+            };
+        },
+        close: () => db.close(),
+    };
+}
+/** Open a SQLite connection on whichever builtin the runtime provides. */
+export function openDb(path) {
+    return globalThis.Bun !== undefined ? openBun(path) : openNode(path);
+}