super-dsh 0.1.0 → 0.1.2

package/agent-omp/cordis.patch.yml

@@ -0,0 +1,92 @@
+# @pgmi-builds/omp-web bundle patch. This file is the `dsh.bundle.patch` layer
+# of the published npm package: when installed via
+#
+#   dsh plugin --profile <name> add @pgmi-builds/omp-web
+#
+# the profile boot merges THIS patch — mount the OMP provider plus disable the
+# native components OMP replaces — exactly like a manual cordis.patch.yml.
+# No profile file edits needed: one command installs and mounts.
+#
+# Profile-specific values are deliberately NOT here: `webserver.port` (port
+# choice) and `settings.path` (settings-under-profile) belong to the user's
+# profile patch layer; `agent-default-model` is tracked dynamically by the
+# bridge from OMP's config.yml (`modelRoles.default`).
+
+# Mount the OMP provider: a Cordis Service that registers an AgentFactory on
+# ctx.agents. The provider bridges the full RPC surface (prompt/follow_up/steer/
+# abort/get_state/get_messages/set_model) plus resume; the model selector is
+# served by an OMP-backed LlmAdapter.
+- insert:
+    - id: omp-provider
+      name: '@pgmi-builds/agent-adapter-omp'
+
+# OMP owns the live agent transcript; disable the built-in loop so it does not
+# double-run alongside the OMP RPC process.
+- id: agent-loop
+  disabled: true
+
+# The native routes register deepseek-official / pi-ai providers; the OMP
+# provider registers its own adapter (one route per OMP provider) on ctx.llm.
+# Leaving them mounted would advertise native models alongside OMP's.
+- id: llm-deepseek
+  disabled: true
+- id: llm-pi-ai
+  disabled: true
+
+# OMP is single-mode: its own RPC process drives tools, so no Dash preset
+# composition is needed.
+- id: agent-presets
+  disabled: true
+
+# Titles come from OMP, not from Dash. The stock `session-title-first-prompt-llm`
+# row would run a Dash-side LLM call (through whatever adapter serves ctx.llm)
+# after the first prompt — that is Dash inventing functionality OMP does not
+# have. OMP's own session file carries a `title` entry (empty unless OMP
+# generates one) exposed via the SDK (`SessionManager.getSessionName()` /
+# `titleSource: 'user' | 'auto'`); the bridge is the only place that may mirror
+# it into a `session/title` event. Until that mirror is wired, leave the title
+# at its creation value (the cwd) — do not let Dash generate one.
+- id: session-title-llm
+  disabled: true
+
+# dsh-shape-session-log: the native jsonl backend is the ONLY sessionPersistence.
+# omp-web feeds it (producer role); native components serve list/page/replay.
+# The plugin no longer provides a union persistence (OmpUnionSessionPersistence
+# is retired) — keep the stock row mounted.
+#
+# Directory picker: the stock `directory-picker-auto` is never a simple alias —
+# it RESOLVES the interaction once per boot and mounts BOTH faces through the
+# loader: the host backend package AND the matching CLIENT SURFACE package
+# (`dsh-client-ui-directory-picker-<kind>`). The client surface is what
+# occupies the workspace picker's directory-flow hole; with the hole empty the
+# client hides the "add workspace" entry entirely (WorkspacePicker: `flowAvailable
+# ? [ADD_WORKSPACE] : []`). NEVER just `disabled: true` this row — that removed
+# the button. Pin the in-app browser by mounting both faces of `browse`
+# ourselves (backend first: the surface's browser half drives the capability the
+# backend registers) and unmounting the auto row.
+- insert:
+    - id: directory-picker-browse
+      name: '@deepseek-ai/dsh-host-directory-picker-browse'
+    - id: directory-picker-browse-surface
+      name: '@deepseek-ai/dsh-client-ui-directory-picker-browse'
+- id: directory-picker
+  disabled: true
+
+# OMP has no runtime approval control — the bridge maps the preset onto omp's
+# launch-only --approval-mode flag. Default to danger-full-access (OMP's own
+# native yolo default). Restate the full 3-preset table: a patch with only
+# defaultPreset silently drops the bundle's 3-preset table to the plugin's
+# built-in 2, breaking the 3:3 Dash<->OMP pairing.
+- id: permission
+  config:
+    presets:
+      read-only:
+        sandbox: read-only
+        approval: ask
+      workspace-write:
+        sandbox: workspace-write
+        approval: ask
+      danger-full-access:
+        sandbox: danger-full-access
+        approval: never
+    defaultPreset: danger-full-access

package/agent-omp/dist/adapter.js

@@ -0,0 +1,36 @@
+/**
+ * OMP-backed `LlmAdapter` registered on `ctx.llm` by the OMP provider.
+ *
+ * The browser model selector never touches the OMP agent directly: it is an
+ * RPC round-trip through the apiproxy, which reads `ctx.llm.listProviders /
+ * listModels / resolveModelInfo` to build the catalog. This adapter answers
+ * those queries from OMP's real model registry (`models.ts`) so the selector
+ * shows OMP's providers and models — never the native deepseek-official /
+ * pi-ai routes, which the profile disables.
+ *
+ * `stream` is never dispatched: OMP owns generation inside its SDK sidecar
+ * (`OmpAgent`), so the adapter only serves catalog/metadata queries. It
+ * throws rather than fabricating a wire route the harness would misuse.
+ */
+import { LlmAdapter, LlmError, } from "@deepseek-ai/dsh-llm";
+import { loadOmpModels, providerDisplayName, toModelInfo, toResolvedModelInfo } from "./models.js";
+export class OmpLlmAdapter extends LlmAdapter {
+    providerInfo(provider) {
+        return { id: provider, name: providerDisplayName(provider) };
+    }
+    async listModels(provider) {
+        return loadOmpModels()
+            .filter((model) => model.provider === provider)
+            .map(toModelInfo);
+    }
+    async resolveModel(provider, model) {
+        const found = loadOmpModels().find((candidate) => candidate.provider === provider && candidate.id === model);
+        if (found === undefined) {
+            throw new LlmError(`OMP provider "${provider}" does not serve model "${model}"`, "MODEL_NOT_FOUND");
+        }
+        return toResolvedModelInfo(found);
+    }
+    stream(_options) {
+        throw new LlmError("the OMP adapter does not stream: OMP owns generation through its rpc agent", "UNSUPPORTED_STREAM");
+    }
+}

package/agent-omp/dist/agent-preset-omp.js

@@ -0,0 +1,171 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+const OMP_PRESET = Object.freeze({
+    id: "omp",
+    trust: "system",
+    path: "",
+    name: "OMP",
+    description: "OMP agent via the omp-web bridge",
+});
+const COMPOSITION_TEXT = [
+    "# OMP (fixed roster)",
+    "",
+    "This deployment runs exactly one agent mode: the OMP provider bridges Dash",
+    "sessions to a native OMP agent over RPC. There is no per-session plugin",
+    "composition to configure, so this preset mounts nothing.",
+    "",
+    "rows: []",
+    "",
+].join("\n");
+/** The standing scope key every `omp` session reads presenters through. */
+const STANDING_KEY = {};
+let SingleOmpPresetRoster = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _remoteList_decorators;
+    let _remoteRead_decorators;
+    let _remoteCopy_decorators;
+    let _remoteDelete_decorators;
+    let _remoteSelect_decorators;
+    return class SingleOmpPresetRoster extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _remoteList_decorators = [Remote("list")];
+            _remoteRead_decorators = [Remote("read")];
+            _remoteCopy_decorators = [Remote("copy")];
+            _remoteDelete_decorators = [Remote("deletePreset")];
+            _remoteSelect_decorators = [Remote("select")];
+            __esDecorate(this, null, _remoteList_decorators, { kind: "method", name: "remoteList", static: false, private: false, access: { has: obj => "remoteList" in obj, get: obj => obj.remoteList }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remoteRead_decorators, { kind: "method", name: "remoteRead", static: false, private: false, access: { has: obj => "remoteRead" in obj, get: obj => obj.remoteRead }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remoteCopy_decorators, { kind: "method", name: "remoteCopy", static: false, private: false, access: { has: obj => "remoteCopy" in obj, get: obj => obj.remoteCopy }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remoteDelete_decorators, { kind: "method", name: "remoteDelete", static: false, private: false, access: { has: obj => "remoteDelete" in obj, get: obj => obj.remoteDelete }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remoteSelect_decorators, { kind: "method", name: "remoteSelect", static: false, private: false, access: { has: obj => "remoteSelect" in obj, get: obj => obj.remoteSelect }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        constructor(ctx) {
+            super(ctx, "agentPresets");
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        get defaultId() {
+            return OMP_PRESET.id;
+        }
+        get roots() {
+            return [];
+        }
+        get authorable() {
+            return false;
+        }
+        async list() {
+            return [OMP_PRESET];
+        }
+        async resolve(id) {
+            if (id === undefined || id === OMP_PRESET.id)
+                return OMP_PRESET;
+            throw new RemoteError("agent-preset/not-found", `agent-presets: preset "${id}" not found (available: omp)`, { agentPreset: id, available: [OMP_PRESET.id] });
+        }
+        async mount(_agentCtx, id) {
+            return this.resolve(id);
+        }
+        async recompose(_agentCtx, id) {
+            return this.resolve(id);
+        }
+        async read(id) {
+            await this.resolve(id);
+            return COMPOSITION_TEXT;
+        }
+        // ── Remote RPC surface (alpha: agentPresets routes come from @Remote) ────
+        // The stock dsh-host-apiproxy mapped cordis methods to routes; alpha serves
+        // them from @Remote decorators on a TypertRemoteService. A plain Service
+        // registers no routes, which is why Settings → Agent Preset 404'd.
+        async remoteList() {
+            if (process.env.OMP_TRACE === "1")
+                process.stderr.write("[omp-roster] remoteList INVOKED\n");
+            return {
+                presets: [
+                    {
+                        id: OMP_PRESET.id,
+                        trust: OMP_PRESET.trust,
+                        isDefault: true,
+                        name: OMP_PRESET.name,
+                        description: OMP_PRESET.description,
+                    },
+                ],
+                authorable: this.authorable,
+            };
+        }
+        async remoteRead(agentPreset) {
+            const preset = await this.resolve(agentPreset);
+            return {
+                agentPreset: preset.id,
+                trust: preset.trust,
+                content: await this.read(preset.id),
+                name: preset.name,
+                description: preset.description,
+            };
+        }
+        async remoteCopy(from, id, name) {
+            await this.copy(from, id, name);
+        }
+        async remoteDelete(id) {
+            await this.remove(id);
+        }
+        /** Fixed roster: one preset, so selecting it is a no-op ack; anything else is unknown. */
+        async remoteSelect(agent, agentPreset) {
+            const preset = await this.resolve(agentPreset);
+            return preset.id;
+        }
+        async copy(_from, id, _name) {
+            throw new RemoteError("agent-preset/read-only", `agent-presets: preset "${id}" cannot be written: the OMP roster is fixed and ships exactly one preset`, { agentPreset: id, reason: "the OMP roster is fixed and ships exactly one preset" });
+        }
+        async remove(id) {
+            throw new RemoteError("agent-preset/read-only", `agent-presets: preset "${id}" cannot be written: the OMP roster is fixed and ships exactly one preset`, { agentPreset: id, reason: "the OMP roster is fixed and ships exactly one preset" });
+        }
+        serviceFor(_agent, _name) {
+            return undefined;
+        }
+        composeFrom(_agentCtx, _parentCtx) {
+            return undefined;
+        }
+        composedPreset(_agentCtx) {
+            return OMP_PRESET.id;
+        }
+        async standingKeyFor(id) {
+            await this.resolve(id);
+            return STANDING_KEY;
+        }
+    };
+})();
+export { SingleOmpPresetRoster };

package/agent-omp/dist/agent-preset-projection.js

@@ -0,0 +1,36 @@
+/**
+ * The `agentPreset` session projection, owned by the bridge.
+ *
+ * Upstream registers this fold from the `dsh-agent-presets` package, which our
+ * patch disables (OMP replaces preset composition wholesale). But the Web UI
+ * depends on the projection regardless: the preset hero chip renders only when
+ * `session.projectionValues.agentPreset` resolves (`presetOf` in
+ * ui-agent-preset/seat-store.ts), and the session-header label reads it too.
+ * Without a registrant the projection is absent for every bridge session and
+ * both surfaces stay blank — roster or no roster (that was the "no omp mode"
+ * bug: the roster service answered `agentPresets/list` 200, yet nothing drove
+ * the per-session projection the chip gates on).
+ *
+ * Same fold as upstream (packages/preset/agent-presets/src/session.ts):
+ * initialized from the creation header, advanced by `agent-preset/selected`
+ * events, which this bridge already synthesizes (`"omp"`) on every session it
+ * prepares. Registered under the provider's own fiber via
+ * `ctx.inject(['sessionProjections'])`, so the key lives exactly as long as
+ * the provider is mounted.
+ */
+import { z } from "zod";
+const agentPresetSchema = z.union([z.string(), z.null()]);
+/** Current Session preset, initialized from its header and advanced by selection events. */
+export const ompAgentPresetProjection = {
+    key: "agentPreset",
+    stateSchema: agentPresetSchema,
+    // omp-web is single-preset: default every session to "omp" so the header
+    // chip resolves for scan-native (never-resumed) sessions too, instead of
+    // only those whose log carries an `agent-preset/selected` event.
+    init: (header) => header.agentPreset ?? "omp",
+    apply: (state, event) => event.type === "agent-preset/selected"
+        ? event.data.agentPreset
+        : state,
+    wire: { viewSchema: agentPresetSchema, view: (state) => state },
+    stateVersion: 1,
+};