super-dsh 0.1.0 → 0.1.2

package/agent-omp/dist/app-home.js

@@ -0,0 +1,86 @@
+/**
+ * OMP runtime app home bootstrap — idempotently creates the runtime's OMP home
+ * (`<DSH_HOME>/agents/omp/.omp`) and seeds it with the OMP config (config.yml /
+ * mcp.json / models.yml / .env) copied once from `~/.omp/agent`. Fail-soft: any
+ * error is reported and the host boot continues — the app home is derived state,
+ * never a boot gate.
+ */
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { OMP_HOME, OMP_NATIVE_HOME } from "./knobs.js";
+/** Config files seeded into the app home from the native OMP agent dir. */
+export const APP_HOME_CONFIG_FILES = ["config.yml", "mcp.json", "models.yml", ".env"];
+/**
+ * Comma/space separated `mcpServers` names the launcher refuses to inherit
+ * (`AW_OMP_MCP_EXCLUDE=zai-vision`). Deployment policy lives in the launcher, so
+ * this module never names a vendor.
+ */
+export const OMP_MCP_EXCLUDE_ENV = "AW_OMP_MCP_EXCLUDE";
+/** Native OMP agent dir (`<OMP_NATIVE_HOME>/agent`) — the copy source. */
+function defaultSourceAgentDir() {
+    return join(OMP_NATIVE_HOME, "agent");
+}
+/** Parse {@link OMP_MCP_EXCLUDE_ENV} into server names. */
+function excludedMcpServers() {
+    return (process.env[OMP_MCP_EXCLUDE_ENV] ?? "")
+        .split(/[\s,]+/)
+        .map((name) => name.trim())
+        .filter((name) => name !== "");
+}
+/**
+ * Drop excluded stdio MCP servers from the app home's `mcp.json`.
+ *
+ * Why this exists: the native `~/.omp/agent/mcp.json` carries a `npx -y
+ * @z_ai/mcp-server@latest` stdio server, and every spawned MCP child is a real
+ * process (a live npx install ~200 MB) that this runtime does not need. Seeding
+ * copies the file verbatim, so the filter runs after seeding and is idempotent:
+ * it only rewrites the document when a listed server was actually present.
+ */
+function pruneMcpServers(appHome, names, warn) {
+    if (names.length === 0)
+        return;
+    const file = join(appHome, "mcp.json");
+    if (!existsSync(file))
+        return;
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    const servers = parsed.mcpServers;
+    if (servers === undefined || typeof servers !== "object" || servers === null)
+        return;
+    const removed = names.filter((name) => Object.hasOwn(servers, name));
+    if (removed.length === 0)
+        return;
+    for (const name of removed)
+        delete servers[name];
+    writeFileSync(file, `${JSON.stringify(parsed, null, 2)}\n`);
+    warn?.(`omp-provider: pruned MCP servers from ${file}: ${removed.join(", ")}`);
+}
+/**
+ * Ensure the app home exists and is seeded. Never overwrites an existing file
+ * (an already-provisioned app home wins); a missing source file is skipped.
+ * Returns the resolved app home path.
+ */
+export function ensureOmpAppHome(options = {}) {
+    const appHome = options.appHome ?? OMP_HOME;
+    const source = options.sourceAgentDir ?? defaultSourceAgentDir();
+    const files = options.files ?? APP_HOME_CONFIG_FILES;
+    try {
+        mkdirSync(appHome, { recursive: true });
+        for (const name of files) {
+            const dest = join(appHome, name);
+            if (existsSync(dest))
+                continue;
+            const src = join(source, name);
+            if (!existsSync(src))
+                continue;
+            copyFileSync(src, dest);
+        }
+        // Deployment policy, data-side: a seeded/kept `mcp.json` may still carry
+        // heavy stdio servers this runtime must not inherit (a vendor name does not
+        // belong in adapter code, so the launcher names them here).
+        pruneMcpServers(appHome, options.excludeMcpServers ?? excludedMcpServers(), options.warn);
+    }
+    catch (error) {
+        options.warn?.(`omp-provider: app-home bootstrap failed (fail-soft): ${String(error)}`);
+    }
+    return appHome;
+}

package/agent-omp/dist/discovery.js

@@ -0,0 +1,116 @@
+import { readFile } from "node:fs/promises";
+import { OMP_DISCOVERY_REFRESH_INTERVAL_MS } from "./knobs.js";
+import { readSkills, readSlashCommands, } from "./omp-disk-discovery.js";
+/** Strip a slash-command name to the host's `/^[a-z][a-z0-9_-]*$/` shape. */
+function sanitizeCommandName(name) {
+    const cleaned = name.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+/, "").slice(0, 64);
+    return cleaned === "" ? "omp-command" : cleaned;
+}
+/**
+ * Register one set of disk-scanned OMP slash commands on the host runtime.
+ * The handler echoes the command body as the result text — a first-pass
+ * surface; a deeper integration would route execution through the bridged
+ * Agent. Returns a disposer for the whole set.
+ */
+export function mountSlashCommands(commands, found) {
+    const disposers = found.map((command) => commands.register({
+        name: sanitizeCommandName(command.name),
+        description: command.description,
+        handler: () => ({ kind: "success", text: command.content }),
+    }));
+    return () => {
+        for (const dispose of disposers) {
+            try {
+                dispose();
+            }
+            catch {
+                // A host-side double-dispose must not break the refresh cycle.
+            }
+        }
+    };
+}
+/**
+ * A refreshable slash-command mount: registers the boot scan immediately,
+ * then `refresh()` swaps the live set for a fresh disk scan (dispose-then-
+ * register, so a removed command file disappears from the `/` menu).
+ */
+export function createSlashCommandMount(commands, cwd) {
+    let dispose = () => { };
+    const refresh = () => {
+        dispose();
+        dispose = mountSlashCommands(commands, readSlashCommands(cwd));
+    };
+    refresh();
+    return {
+        refresh,
+        disposeAll: () => dispose(),
+    };
+}
+/**
+ * Mount OMP discovery on the host seams. Fail-open: a missing `skills` or
+ * `commands` service leaves the feature dormant, never blocks host boot.
+ *
+ * @param ctx - host plugin context.
+ */
+export function installOmpDiscovery(ctx) {
+    // Skills: a discovery provider whose `list(cwd)` scans OMP's disk roots for
+    // the caller's workspace; the body is read lazily from SKILL.md in `get`.
+    ctx.inject(["skills"], (scoped) => {
+        const skills = scoped.get("skills");
+        if (skills === undefined)
+            return;
+        skills.registerProvider(() => ({
+            name: "omp",
+            list: async (options) => {
+                const found = readSkills(options.cwd);
+                return found.map((skill, rank) => ({
+                    name: skill.name,
+                    description: skill.description,
+                    rank,
+                    locator: skill.filePath,
+                    path: skill.filePath,
+                    invocation: { modelInvocable: true, userInvocable: true },
+                    source: "custom",
+                    provider: "omp",
+                }));
+            },
+            get: async (candidate) => {
+                const content = await readFile(String(candidate.locator), "utf8").catch(() => "");
+                return {
+                    name: candidate.name,
+                    description: candidate.description,
+                    content,
+                    invocation: { modelInvocable: true, userInvocable: true },
+                    source: "custom",
+                    provider: "omp",
+                };
+            },
+        }));
+    });
+    // Slash commands: mount the boot scan, then re-scan on the hourly discovery
+    // cadence (pure disk reads; `0` disables). The interval + live registrations
+    // are fiber-owned: torn down with the plugin context.
+    ctx.inject(["commands"], (scoped) => {
+        const commands = scoped.get("commands");
+        if (commands === undefined)
+            return;
+        const mount = createSlashCommandMount(commands);
+        let timer;
+        if (OMP_DISCOVERY_REFRESH_INTERVAL_MS > 0) {
+            timer = setInterval(() => {
+                try {
+                    mount.refresh();
+                }
+                catch {
+                    // A bad refresh must never kill the interval or the host.
+                }
+            }, OMP_DISCOVERY_REFRESH_INTERVAL_MS);
+            timer.unref?.();
+        }
+        ctx.effect(() => () => {
+            if (timer !== undefined)
+                clearInterval(timer);
+            mount.disposeAll();
+        }, "ompDiscovery.slashCommands");
+    });
+}

package/agent-omp/dist/inbox.js

@@ -0,0 +1,53 @@
+export class Inbox {
+    #nextTurn = [];
+    #nextStep = [];
+    get nextTurn() {
+        return this.#nextTurn;
+    }
+    get nextStep() {
+        return this.#nextStep;
+    }
+    clear() {
+        this.#nextTurn = [];
+        this.#nextStep = [];
+    }
+    append(target, message) {
+        this.#list(target).push(message);
+    }
+    prepend(target, message) {
+        this.#list(target).unshift(message);
+    }
+    replace(messageId, newMessage) {
+        const list = this.#find(messageId);
+        if (list === undefined)
+            return false;
+        const index = list.findIndex((message) => message.id === messageId);
+        if (index < 0)
+            return false;
+        list.splice(index, 1, newMessage);
+        return true;
+    }
+    remove(messageId) {
+        const list = this.#find(messageId);
+        if (list === undefined)
+            return false;
+        const index = list.findIndex((message) => message.id === messageId);
+        if (index < 0)
+            return false;
+        list.splice(index, 1);
+        return true;
+    }
+    splice(target, start, deleteCount, inserted) {
+        return this.#list(target).splice(start, deleteCount, ...inserted);
+    }
+    #list(target) {
+        return target === "next-turn" ? this.#nextTurn : this.#nextStep;
+    }
+    #find(messageId) {
+        if (this.#nextTurn.some((message) => message.id === messageId))
+            return this.#nextTurn;
+        if (this.#nextStep.some((message) => message.id === messageId))
+            return this.#nextStep;
+        return undefined;
+    }
+}