super-dsh 0.1.0 → 0.1.2

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

@@ -0,0 +1,169 @@
+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 PI_PRESET = Object.freeze({
+    id: "pi",
+    trust: "system",
+    path: "",
+    name: "Pi",
+    description: "Pi agent via the agent-pi adapter",
+});
+const COMPOSITION_TEXT = [
+    "# Pi (fixed roster)",
+    "",
+    "This deployment runs exactly one agent mode: the Pi provider bridges Dash",
+    "sessions to a native pi agent over the @earendil-works/pi-coding-agent SDK.",
+    "There is no per-session plugin composition to configure, so this preset",
+    "mounts nothing.",
+    "",
+    "rows: []",
+    "",
+].join("\n");
+/** The standing scope key every `pi` session reads presenters through. */
+const STANDING_KEY = {};
+let SinglePiPresetRoster = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _remoteList_decorators;
+    let _remoteRead_decorators;
+    let _remoteCopy_decorators;
+    let _remoteDelete_decorators;
+    let _remoteSelect_decorators;
+    return class SinglePiPresetRoster 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 PI_PRESET.id;
+        }
+        get roots() {
+            return [];
+        }
+        get authorable() {
+            return false;
+        }
+        async list() {
+            return [PI_PRESET];
+        }
+        async resolve(id) {
+            if (id === undefined || id === PI_PRESET.id)
+                return PI_PRESET;
+            throw new RemoteError("agent-preset/not-found", `agent-presets: preset "${id}" not found (available: pi)`, { agentPreset: id, available: [PI_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) ────
+        async remoteList() {
+            if (process.env.PI_TRACE === "1")
+                process.stderr.write("[pi-roster] remoteList INVOKED\n");
+            return {
+                presets: [
+                    {
+                        id: PI_PRESET.id,
+                        trust: PI_PRESET.trust,
+                        isDefault: true,
+                        name: PI_PRESET.name,
+                        description: PI_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 Pi roster is fixed and ships exactly one preset`, { agentPreset: id, reason: "the Pi 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 Pi roster is fixed and ships exactly one preset`, { agentPreset: id, reason: "the Pi roster is fixed and ships exactly one preset" });
+        }
+        serviceFor(_agent, _name) {
+            return undefined;
+        }
+        composeFrom(_agentCtx, _parentCtx) {
+            return undefined;
+        }
+        composedPreset(_agentCtx) {
+            return PI_PRESET.id;
+        }
+        async standingKeyFor(id) {
+            await this.resolve(id);
+            return STANDING_KEY;
+        }
+    };
+})();
+export { SinglePiPresetRoster };

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

@@ -0,0 +1,29 @@
+/**
+ * The `agentPreset` session projection, owned by the adapter.
+ *
+ * Upstream registers this fold from the `dsh-agent-presets` package, which our
+ * patch disables (the pi provider replaces preset composition wholesale).
+ * But the Web UI depends on the projection regardless: the preset hero chip
+ * renders only when `session.projectionValues.agentPreset` resolves, and the
+ * session-header label reads it too. Without a registrant the projection is
+ * absent for every adapter session and both surfaces stay blank (the omp
+ * line's "no mode" bug).
+ *
+ * Same fold as upstream; adapter-pi is single-preset: default every session
+ * to "pi" so the header chip resolves for scan-native (never-resumed)
+ * sessions too. Registered under the provider's own fiber via
+ * `ctx.inject(['sessionProjections'])`.
+ */
+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 piAgentPresetProjection = {
+    key: "agentPreset",
+    stateSchema: agentPresetSchema,
+    init: (header) => header.agentPreset ?? "pi",
+    apply: (state, event) => event.type === "agent-preset/selected"
+        ? event.data.agentPreset
+        : state,
+    wire: { viewSchema: agentPresetSchema, view: (state) => state },
+    stateVersion: 1,
+};