super-dsh 0.1.6 → 0.1.10-e

package/agent-omp/dist/permission.js

@@ -3,20 +3,28 @@
  *
  * OMP has no runtime approval control: `--approval-mode` is a launch flag, no
  * RPC changes it mid-session. Dash's 3-way permission preset is therefore
- * resolved once, when the OMP child is spawned, and mapped explicitly:
+ * resolved ONCE, at the spawn of that session's `omp --mode rpc` child, and
+ * mapped explicitly:
  *
  *   danger-full-access → `--approval-mode yolo`   (OMP's own native default)
  *   workspace-write    → `--approval-mode write`
  *   read-only          → `--approval-mode always-ask`
  *   no explicit preset → yolo (native default)
  *
+ * "At the spawn" is load-bearing, not incidental. The Dash session is prepared
+ * (and `pinInitialPermission`-stamped) only AFTER the transport wrapper exists,
+ * and the new-chat permission pick arrives as a later `permission/preset` — the
+ * child materializes on the first prompt, so the launch flag must be read from
+ * the session at THAT moment, never frozen at create. See
+ * {@link resolveSpawnPermission}.
+ *
  * `OMP_APPROVAL_MODE` (a valid mode) overrides the mapping — headless test
  * runs pin the flag without composing a preset default.
  *
- * The preset is a Dash-side session fact OMP never records. It now lives in
- * the centralized index (`sessions.permission_preset`), seeded once from the
- * legacy per-session webui.json by the migration; webui.json stays on disk
- * but is never read or written again (D3).
+ * The preset is a Dash-side session fact OMP never records. It lives in the
+ * dsh session log (`permission/preset`, the event `/permission` writes) and is
+ * mirrored into the centralized index (`sessions.permission_preset`) at first
+ * spawn; the index row is only a fallback for logs predating the event.
  */
 import { dirname, join } from "node:path";
 /** The approval modes OMP actually implements (unknown modes degrade to yolo). */
@@ -71,6 +79,63 @@ export function presetFromEvents(events) {
     }
     return undefined;
 }
+/**
+ * Resolve a spawn's `--approval-mode` (and the preset to record for it) from
+ * the session's OWN log, evaluated at the moment the child materializes.
+ *
+ * Order of authority: the last valid `permission/preset` (= the user's pick in
+ * the new chat, or the draft's `pinInitialPermission` stamp) → `fallbackPreset`
+ * (the composition default for a create, the bridge-index row for a resume of a
+ * log that predates the event) → OMP's native default (`yolo`). An
+ * `OMP_APPROVAL_MODE` env override (headless runs) still wins over all of them.
+ *
+ * @param events - the live session's events (never a stale create-time read).
+ * @param fallbackPreset - used only when the log carries no valid preset.
+ * @param envMode - `envApprovalMode()`; undefined when unset or invalid.
+ * @returns the launch flag value plus the preset that produced it.
+ */
+export function resolveSpawnPermission(events, fallbackPreset, envMode) {
+    const preset = presetFromEvents(events) ?? (isPresetName(fallbackPreset) ? fallbackPreset : undefined);
+    return { approvalMode: envMode ?? ompApprovalMode(preset), preset };
+}
+/**
+ * Decide a `/permission` invocation for one OMP session.
+ *
+ * A permission pick can only become real at the child's launch, so the shadow
+ * accepts it exactly while no child exists (the new-chat draft, or a resumed
+ * session before its first prompt) and refuses it afterwards — appending a
+ * preset the running `omp` cannot honor would make the UI lie about the
+ * session's effective policy.
+ *
+ * @param input.rawInput - the preset name as typed (may be empty or padded).
+ * @param input.spawned - whether THIS session's `omp --mode rpc` child exists.
+ * @param input.names - the host's advertised preset names.
+ * @param input.current - the session's current preset (for the bare command).
+ * @returns the decision; the caller performs the write for `apply`.
+ */
+export function ompPermissionCommand(input) {
+    const available = input.names.join(", ");
+    const name = input.rawInput.trim();
+    if (name === "") {
+        return {
+            action: "settled",
+            result: { kind: "success", text: `current preset ${input.current} (available: ${available})` },
+        };
+    }
+    if (!input.names.includes(name)) {
+        return { action: "settled", result: { kind: "error", text: `unknown preset "${name}" (available: ${available})` } };
+    }
+    if (input.spawned) {
+        return {
+            action: "settled",
+            result: {
+                kind: "error",
+                text: `the OMP session is already running with a fixed approval policy: pick "${name}" in a new chat, before the first prompt`,
+            },
+        };
+    }
+    return { action: "apply", preset: name, result: { kind: "success", text: `preset ${name}` } };
+}
 /**
  * The three Dash events `pinInitialPermission` stamps for a fresh session,
  * in its append order (preset, sandbox, approval). Cold replay prepends

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

@@ -0,0 +1,409 @@
+/**
+ * OmpRpcClient — NDJSON client over `omp --mode rpc` stdio (RPC transport line).
+ *
+ * Ported from `git show 6d2fbe1:apps/multi-agent/agent-omp/src/rpc.ts`.
+ *
+ * Protocol: `ready` is a plain event; the current binary announces
+ * `{type:"ready",protocolVersion:1,supportedProtocolVersions:[1,2],
+ *   maxFrameBytes:1048576,maxReassembledFrameBytes:67108864}`.
+ * We deliberately DO NOT call `negotiate_protocol`: v1 is plain NDJSON, which
+ * is exactly what this reader implements. Negotiating 2 would switch the peer
+ * to >1MiB frame chunking and require a reassembler (registered gap, spec §4).
+ */
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** `$OMP_EXECUTABLE` wins; else PATH, else the common native-installer spots. */
+export function resolveOmpExecutable() {
+    const configured = process.env.OMP_EXECUTABLE?.trim();
+    if (configured !== undefined && configured !== "")
+        return configured;
+    for (const dir of (process.env.PATH ?? "").split(":").filter(Boolean)) {
+        if (existsSync(join(dir, "omp")))
+            return "omp";
+    }
+    for (const candidate of [join(homedir(), ".local/bin/omp"), "/usr/local/bin/omp"]) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return "omp";
+}
+/**
+ * Readiness deadline: bound the `ready` handshake so a broken spawn fails
+ * instead of hanging the caller forever. OMP can take a long time to emit
+ * `ready` while it performs MCP server connection and model discovery — a
+ * localhost model provider that drops (rather than rejects) the connection can
+ * hang until its own timeout, and a cold `npx` MCP server can take tens of
+ * seconds to spawn. The default is therefore generous; `0` disables the
+ * deadline. Override with `OMP_READY_TIMEOUT_MS`.
+ */
+const READY_TIMEOUT_MS = parseTimeout(process.env.OMP_READY_TIMEOUT_MS, 120_000);
+/**
+ * Per-command response deadline: bound every blocking request so an
+ * unresponsive OMP (e.g. a hung `get_messages` during resume) fails within a
+ * fixed window instead of stalling the caller indefinitely. `0` disables the
+ * deadline. Override with `OMP_COMMAND_TIMEOUT_MS`.
+ */
+const COMMAND_TIMEOUT_MS = parseTimeout(process.env.OMP_COMMAND_TIMEOUT_MS, 30_000);
+/** Parse a non-negative millisecond timeout; empty/missing → `fallback`, invalid → `fallback`. */
+function parseTimeout(raw, fallback) {
+    if (raw === undefined || raw.trim() === "")
+        return fallback;
+    const value = Number(raw);
+    return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+/**
+ * Grace period between SIGTERM and the SIGKILL escalation that guarantees a
+ * stubborn `omp` (and its tool subprocesses) never survives teardown.
+ */
+const KILL_GRACE_MS = 2_000;
+export class OmpRpcClient {
+    #proc;
+    #listeners = new Set();
+    #titleListeners = new Set();
+    #failureListeners = new Set();
+    #pending = new Map();
+    #ready;
+    #readyResolve;
+    #readyReject;
+    #nextId = 0;
+    #buffer = "";
+    #closed = false;
+    #killed = false;
+    #killTimer = null;
+    #failure = null;
+    /** Spawn `omp --mode rpc` and resolve once the `ready` handshake arrives. */
+    static async spawn(args = [], cwd) {
+        const client = new OmpRpcClient(args, cwd);
+        await client.#ready;
+        return client;
+    }
+    constructor(args, cwd) {
+        this.#proc = spawn(resolveOmpExecutable(), ["--mode", "rpc", ...args], {
+            stdio: ["pipe", "pipe", "pipe"],
+            // Own process group so teardown can signal omp AND its tool subprocesses.
+            detached: true,
+            ...(cwd === undefined ? {} : { cwd }),
+        });
+        this.#ready = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.#fail(new Error("omp --mode rpc: timed out waiting for the `ready` event"));
+            }, READY_TIMEOUT_MS);
+            this.#readyResolve = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+            this.#readyReject = (error) => {
+                clearTimeout(timer);
+                reject(error);
+            };
+        });
+        this.#proc.stdout.setEncoding("utf8");
+        this.#proc.stdout.on("data", (chunk) => this.#onData(chunk));
+        this.#proc.stderr.setEncoding("utf8");
+        this.#proc.stderr.on("data", (chunk) => {
+            // OMP writes diagnostics to stderr; surface them for debugging.
+            process.stderr.write(chunk);
+        });
+        this.#proc.on("error", (error) => this.#fail(error));
+        this.#proc.on("exit", (code) => {
+            if (this.#killTimer !== null) {
+                clearTimeout(this.#killTimer);
+                this.#killTimer = null;
+            }
+            if (!this.#closed)
+                this.#fail(new Error(`omp --mode rpc exited unexpectedly (code ${code})`));
+        });
+    }
+    /** Register an event listener; returns the unsubscriber. */
+    on(listener) {
+        this.#listeners.add(listener);
+        return () => {
+            this.#listeners.delete(listener);
+        };
+    }
+    /** Register a failure listener invoked when the child exits or errors. Returns the unsubscriber. */
+    onFailure(listener) {
+        this.#failureListeners.add(listener);
+        return () => {
+            this.#failureListeners.delete(listener);
+        };
+    }
+    /**
+     * Write one fire-and-forget command that must NOT carry a correlation id.
+     * `extension_ui_response` keys its `id` to the originating UI request, so the
+     * correlation-adding `send()` would clobber it.
+     */
+    sendRaw(command) {
+        if (this.#failure !== null || this.#closed)
+            return;
+        try {
+            this.#proc.stdin.write(JSON.stringify(command) + "\n");
+        }
+        catch (error) {
+            process.stderr.write(`omp rpc write error: ${String(error)}\n`);
+        }
+    }
+    /**
+     * Send one command and resolve with its `response`. Fire-and-forget callers
+     * may ignore the promise. A per-command deadline (see COMMAND_TIMEOUT_MS)
+     * rejects the request if OMP never answers, so blocking callers
+     * (`getMessages`) can't stall indefinitely; pass `timeoutMs` to override,
+     * or `0` to disable the deadline.
+     */
+    send(command, timeoutMs = COMMAND_TIMEOUT_MS) {
+        if (this.#failure !== null)
+            return Promise.reject(this.#failure);
+        if (this.#closed)
+            return Promise.reject(new Error("omp rpc client is closed"));
+        const id = `omp-${++this.#nextId}`;
+        return new Promise((resolve, reject) => {
+            const pending = {
+                resolve,
+                reject,
+                clear: () => { },
+            };
+            if (timeoutMs > 0) {
+                const timer = setTimeout(() => {
+                    if (this.#pending.delete(id)) {
+                        reject(new Error(`omp rpc command timed out after ${timeoutMs}ms`));
+                    }
+                }, timeoutMs);
+                pending.clear = () => clearTimeout(timer);
+            }
+            this.#pending.set(id, pending);
+            try {
+                this.#proc.stdin.write(JSON.stringify({ ...command, id }) + "\n");
+            }
+            catch (error) {
+                this.#pending.delete(id);
+                pending.clear();
+                reject(error);
+            }
+        });
+    }
+    /** Query `get_state`; returns the state payload. */
+    async getState() {
+        const response = await this.send({ type: "get_state" });
+        if (!response.success)
+            throw new Error(`omp get_state failed: ${String(response.error ?? "unknown error")}`);
+        return (response.data ?? { isStreaming: false });
+    }
+    /** Query `get_messages`; returns the full conversation. */
+    async getMessages() {
+        const response = await this.send({ type: "get_messages" });
+        if (!response.success)
+            throw new Error(`omp get_messages failed: ${String(response.error ?? "unknown error")}`);
+        const data = response.data;
+        return data?.messages ?? [];
+    }
+    /** Query `get_session_stats`; live token/context/cost accounting (live sessions only). */
+    async getSessionStats() {
+        const response = await this.send({ type: "get_session_stats" });
+        if (!response.success)
+            throw new Error(`omp get_session_stats failed: ${String(response.error ?? "unknown error")}`);
+        return (response.data ?? {});
+    }
+    /** Query `get_subagents`; live subagent registry (fail-soft: [] when unavailable). */
+    async getSubagents() {
+        try {
+            const response = await this.send({ type: "get_subagents" });
+            if (!response.success)
+                return [];
+            const data = response.data;
+            return data?.subagents ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Start a turn with a user prompt. On an idle session `prompt` wakes the
+     * agent and starts a fresh turn. Never send this while OMP is streaming:
+     * without `streamingBehavior` OMP rejects it, and `prompt` with
+     * `streamingBehavior: "followUp"` queues with `resumeIfIdle: false` (delivered
+     * as a user message on idle, never auto-generating a turn).
+     */
+    prompt(message) {
+        return this.send({ type: "prompt", message });
+    }
+    /**
+     * Queue a follow-up on a busy session. OMP delivers it as the next turn's
+     * user message once the current turn ends AND auto-generates that turn —
+     * the dedicated `follow_up` command's connection layer hardcodes
+     * `resumeIfIdle: true` (unlike `prompt` + streamingBehavior). Verified
+     * empirically: docs/probe-omp-followup.mjs.
+     */
+    followUp(message) {
+        return this.send({ type: "follow_up", message });
+    }
+    /** Steer an in-flight turn with a user message. */
+    steer(message) {
+        return this.send({ type: "steer", message });
+    }
+    /** Select the active model by provider + model id (e.g. `deepseek`/`deepseek-v4-pro`). */
+    setModel(provider, modelId) {
+        return this.send({ type: "set_model", provider, modelId });
+    }
+    /** Abort the current streaming run. */
+    abort() {
+        return this.send({ type: "abort" });
+    }
+    /** Discard the current conversation and start a fresh OMP session. */
+    newSession() {
+        return this.send({ type: "new_session" });
+    }
+    /** Title frames (OMP `session_info_update.title`, plus `setTitle` when the
+     *  child runs with `PI_RPC_EMIT_TITLE=1`). Returns the unsubscriber. */
+    onTitle(listener) {
+        this.#titleListeners.add(listener);
+        return () => { this.#titleListeners.delete(listener); };
+    }
+    /** System prompt as OMP renders it (v18 `get_state.systemPrompt`). */
+    async getSystemPrompt() {
+        try {
+            const state = await this.getState();
+            return state.systemPrompt;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Context-usage snapshot for pre/post compact metering (fail-soft). */
+    async contextUsage() {
+        try {
+            const state = await this.getState();
+            return state.contextUsage;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Compact the live conversation (RPC `compact` command). */
+    compact(customInstructions) {
+        return this.send(customInstructions === undefined
+            ? { type: "compact" }
+            : { type: "compact", customInstructions });
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        if (process.env.OMP_TRACE === "1") {
+            process.stderr.write(`[omp-rpc ${Date.now() % 1_000_000}] close() stack=${new Error().stack?.split("\n").slice(1, 6).join(" <- ")}\n`);
+        }
+        this.#kill();
+        this.#fail(new Error("omp rpc client closed"));
+    }
+    /** SIGTERM the process group, escalating to SIGKILL if it lingers. */
+    #kill() {
+        if (this.#killed)
+            return;
+        this.#killed = true;
+        const pid = this.#proc.pid;
+        if (pid === undefined)
+            return;
+        try {
+            process.kill(-pid, "SIGTERM");
+        }
+        catch {
+            return; // group already gone
+        }
+        this.#killTimer = setTimeout(() => {
+            this.#killTimer = null;
+            try {
+                process.kill(-pid, "SIGKILL");
+            }
+            catch {
+                // already dead
+            }
+        }, KILL_GRACE_MS);
+    }
+    #onData(chunk) {
+        this.#buffer += chunk;
+        let index;
+        while ((index = this.#buffer.indexOf("\n")) >= 0) {
+            let line = this.#buffer.slice(0, index);
+            this.#buffer = this.#buffer.slice(index + 1);
+            if (line.endsWith("\r"))
+                line = line.slice(0, -1);
+            if (line.trim() === "")
+                continue;
+            this.#onLine(line);
+        }
+    }
+    #onLine(line) {
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            return; // ignore malformed lines
+        }
+        if (record.type === "ready") {
+            this.#readyResolve();
+            return;
+        }
+        if (record.type === "session_info_update" && typeof record.title === "string" && record.title !== "") {
+            for (const listener of [...this.#titleListeners]) {
+                try {
+                    listener(record.title);
+                }
+                catch { /* contained */ }
+            }
+        }
+        if (record.type === "setTitle" && typeof record.title === "string" && record.title !== "") {
+            for (const listener of [...this.#titleListeners]) {
+                try {
+                    listener(record.title);
+                }
+                catch { /* contained */ }
+            }
+        }
+        if (record.type === "response") {
+            const response = record;
+            if (response.id !== undefined) {
+                const pending = this.#pending.get(response.id);
+                if (pending !== undefined) {
+                    this.#pending.delete(response.id);
+                    pending.clear();
+                    pending.resolve(response);
+                }
+            }
+            return;
+        }
+        for (const listener of [...this.#listeners]) {
+            try {
+                listener(record);
+            }
+            catch (error) {
+                // Listener failures are contained — one bad observer must not break the stream.
+                process.stderr.write(`omp rpc listener error: ${String(error)}\n`);
+            }
+        }
+    }
+    #fail(error) {
+        if (this.#failure !== null)
+            return;
+        this.#failure = error;
+        // Reject an in-flight handshake immediately (fix: not just via the 30s timeout).
+        this.#readyReject(error);
+        for (const pending of this.#pending.values()) {
+            pending.clear();
+            pending.reject(error);
+        }
+        this.#pending.clear();
+        // Any failure path (ready-timeout, pre-ready exit, spawn error) must also
+        // terminate the child so no orphan keeps the session file held.
+        this.#kill();
+        for (const listener of [...this.#failureListeners]) {
+            try {
+                listener(error);
+            }
+            catch (listenerError) {
+                process.stderr.write(`omp rpc failure listener error: ${String(listenerError)}\n`);
+            }
+        }
+    }
+}

package/agent-omp/dist/world-plugin.js

@@ -16,15 +16,42 @@
  *      per-label `/<label>/api` + `/<label>/api/remote.mux` mounts retired
  *      in T-C, `mountWorld` deleted in T-D).
  */
-import { mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
 import { join } from 'node:path';
-import { spawnWorld, registerAgent, setReady, registerForeignTarget, registerHostMount, worldMountPatches, provisionWorldProfile, resolveInstallAnchor, } from '../../superd-hub/dist/index.js';
+import { spawnWorld, registerAgent, unregisterAgent, setReady, registerForeignTarget, registerHostMount, worldMountPatches, provisionWorldProfile, resolveInstallAnchor, } from '../../superd-hub/dist/index.js';
+import { resolveOmpExecutable } from './rpc-client.js';
 export const name = 'agent-omp';
 /** Runtime key — also the mount label. */
 const KEY = 'omp';
+/**
+ * Startup diagnostic (spec §3.5): the OMP world runs the operator's own `omp`
+ * binary over `omp --mode rpc` — the adapter bundles no OMP copy, so a missing
+ * binary fails at the FIRST PROMPT, not at boot. Probe the resolution order
+ * once and say so explicitly instead of mounting silently; readiness semantics
+ * are unchanged (they follow the world mount, not this probe).
+ */
+function diagnoseOmpBinary() {
+    const executable = resolveOmpExecutable();
+    // A bare name is what the resolver yields for BOTH a PATH hit and "nothing
+    // installed" — walk PATH to tell those apart. A slashed candidate is already
+    // a concrete path and is checked directly.
+    const present = executable.includes('/')
+        ? existsSync(executable)
+        : (process.env.PATH ?? '').split(':').filter(Boolean).some((dir) => existsSync(join(dir, executable)));
+    if (!present) {
+        console.error('[super-dsh] omp binary not found (checked $OMP_EXECUTABLE, PATH, ~/.local/bin/omp) — the OMP world will fail at first prompt');
+    }
+}
 export function apply(ctx) {
-    registerAgent({ key: KEY, label: 'OMP', ready: false });
+    diagnoseOmpBinary();
+    // Fiber-scoped roster entry: disabling the row disposes this fiber and the
+    // entry must go with it, otherwise a re-enable dies on `roster: duplicate
+    // agent key omp` (same defect the omp-sdk acceptance surfaced live).
+    ctx.effect?.(() => {
+        registerAgent({ key: KEY, label: 'OMP', ready: false });
+        return () => unregisterAgent(KEY);
+    }, `agent-${KEY}: roster`);
     // Harness resolver (env → ~/.dsh): a consumer install has no DSH_HOME and
     // no cwd contract — deriving the world root from cwd spawns worlds into a
     // garbage tree or throws inside apply() and kills the whole host boot.
@@ -64,6 +91,12 @@ export function apply(ctx) {
         ctx.effect?.(() => () => {
             dropHostMount();
         }, `agent-${KEY}: mount`);
+        // Unloading the row must unload the world: disposing the world's fiber
+        // disposes its provider, which closes every held transport (and therefore
+        // the `omp --mode rpc` children).
+        ctx.effect?.(() => () => {
+            void ctxW.fiber?.dispose();
+        }, `agent-${KEY}: world teardown`);
         return ctxW;
     })().catch((cause) => {
         // A failed world degrades to a not-ready roster row; a rejected provided

package/agent-omp/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pgmi-builds/agent-omp",
   "version": "0.1.0",
-  "description": "OMP Web: OMP provider for DeepSeek Harness (dsh) — an AgentFactory that embeds OMP via the @oh-my-pi/pi-coding-agent SDK (Bun sidecar) and bridges OMP's session surface into Dash Agent/Session contracts.",
+  "description": "OMP Web: OMP provider for DeepSeek Harness (dsh) — an AgentFactory that drives the operator's own omp binary as an `omp --mode rpc` child (NDJSON protocol v1 over stdio) and bridges OMP's session surface into Dash Agent/Session contracts.",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
@@ -11,7 +11,6 @@
   "files": [
     "dist",
     "lib",
-    "sidecar",
     "cordis.patch.yml",
     "README.md"
   ],
@@ -32,10 +31,7 @@
     "build-client": "npm run typecheck:client && tsx scripts/build-client.ts",
     "test": "node --test test/*.test.mjs"
   },
-  "dependencies": {
-    "@oh-my-pi/pi-coding-agent": "^18.1.14",
-    "bun": "^1.4.2"
-  },
+  "dependencies": {},
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-agent": ">=0.1.5-0 <0.3.0-0",