super-dsh 0.1.6 → 0.1.10

package/agent-omp-sdk/dist/permission.d.ts

@@ -0,0 +1,138 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Session, SessionEvent } from "@deepseek-ai/dsh-session";
+/** The Dash preset table (mirrors the base bundle's permission plugin config). */
+declare const PRESETS: {
+    readonly "danger-full-access": {
+        readonly sandbox: "danger-full-access";
+        readonly approval: "never";
+        readonly ompMode: "yolo";
+    };
+    readonly "workspace-write": {
+        readonly sandbox: "workspace-write";
+        readonly approval: "ask";
+        readonly ompMode: "write";
+    };
+    readonly "read-only": {
+        readonly sandbox: "read-only";
+        readonly approval: "ask";
+        readonly ompMode: "always-ask";
+    };
+};
+/**
+ * The two permission event keys this module reads/synthesizes that the
+ * locally-resolved dsh-session build does not know (upstream declares them
+ * in dsh-permission-presets / dsh-sandbox-policy, whose types this project
+ * does not reference). Mirrored verbatim so `SessionEvent` narrows.
+ */
+declare module "@deepseek-ai/dsh-session/types" {
+    interface SessionEventMap {
+        "permission/preset": {
+            preset: string;
+        };
+        "sandbox/mode": {
+            mode: "read-only" | "workspace-write" | "danger-full-access";
+            source?: "delegation";
+        };
+    }
+}
+type PresetName = keyof typeof PRESETS;
+/** Narrow an untrusted value to a known preset name. */
+export declare function isPresetName(raw: unknown): raw is PresetName;
+/**
+ * `OMP_APPROVAL_MODE` when it names a mode OMP implements, else undefined.
+ * An invalid value is IGNORED (the preset mapping applies) — the old
+ * fall-back-to-`write` behavior silently downgraded from OMP's native yolo.
+ */
+export declare function envApprovalMode(): string | undefined;
+/** Map a preset onto OMP's `--approval-mode` flag value; no preset → yolo. */
+export declare function ompApprovalMode(preset: string | undefined): string;
+/**
+ * The default preset for FUTURE sessions, as the permission service
+ * resolves it (settings-backed; the profile patch pins the base default).
+ * Undefined when the service is absent or its getter fails — callers fall
+ * back to OMP's native default.
+ */
+export declare function defaultPermissionPreset(ctx: Context): string | undefined;
+/** The session's effective preset: the last `permission/preset` event. */
+export declare function presetFromEvents(events: readonly SessionEvent[]): string | 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 declare function resolveSpawnPermission(events: readonly SessionEvent[], fallbackPreset: string | undefined, envMode: string | undefined): {
+    approvalMode: string;
+    preset: string | undefined;
+};
+/**
+ * The write slice of `ctx.permissionPresets` the `/permission` command mirrors:
+ * `names`/`current` for the settled answers, `set` for the durable write (the
+ * same public call the webhook plugin uses to pin a session's initial preset —
+ * it appends `permission/preset` + the knob events and touches no live agent).
+ */
+export interface PermissionPresetsWriteSlice {
+    readonly names: readonly string[];
+    current(session: Session): string;
+    set(session: Session, name: string): void;
+}
+/** One `/permission` outcome, shaped exactly as `dsh-commands` expects. */
+export interface PermissionCommandOutcome {
+    kind: "success" | "error";
+    text: string;
+}
+/**
+ * What the adapter's `/permission` shadow must do: `apply` writes the preset to
+ * the session (the caller then returns `result`), `settled` returns it as-is.
+ */
+export type OmpPermissionDecision = {
+    action: "apply";
+    preset: string;
+    result: PermissionCommandOutcome;
+} | {
+    action: "settled";
+    result: PermissionCommandOutcome;
+};
+/**
+ * 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 declare function ompPermissionCommand(input: {
+    rawInput: string;
+    spawned: boolean;
+    names: readonly string[];
+    current: string;
+}): OmpPermissionDecision;
+/**
+ * The three Dash events `pinInitialPermission` stamps for a fresh session,
+ * in its append order (preset, sandbox, approval). Cold replay prepends
+ * them so the UI shows the session's permission after wrapper restarts.
+ */
+export declare function permissionEventsFor(preset: PresetName, time: number): SessionEvent[];
+/**
+ * The bridge's legacy per-session artifact path (the migration reads this to
+ * import the old `dashSessionId` / `permissionPreset` once). Kept read-only;
+ * nothing writes it after the migration.
+ */
+export declare function webuiArtifactPath(sessionFile: string): string;
+export {};

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

@@ -0,0 +1,161 @@
+/**
+ * Dash permission preset ↔ OMP approval mode.
+ *
+ * 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, 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 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). */
+const APPROVAL_MODES = ["write", "always-ask", "yolo"];
+/** The Dash preset table (mirrors the base bundle's permission plugin config). */
+const PRESETS = {
+    "danger-full-access": { sandbox: "danger-full-access", approval: "never", ompMode: "yolo" },
+    "workspace-write": { sandbox: "workspace-write", approval: "ask", ompMode: "write" },
+    "read-only": { sandbox: "read-only", approval: "ask", ompMode: "always-ask" },
+};
+/** Narrow an untrusted value to a known preset name. */
+export function isPresetName(raw) {
+    return typeof raw === "string" && Object.hasOwn(PRESETS, raw);
+}
+/**
+ * `OMP_APPROVAL_MODE` when it names a mode OMP implements, else undefined.
+ * An invalid value is IGNORED (the preset mapping applies) — the old
+ * fall-back-to-`write` behavior silently downgraded from OMP's native yolo.
+ */
+export function envApprovalMode() {
+    const raw = process.env.OMP_APPROVAL_MODE;
+    return raw !== undefined && APPROVAL_MODES.includes(raw) ? raw : undefined;
+}
+/** Map a preset onto OMP's `--approval-mode` flag value; no preset → yolo. */
+export function ompApprovalMode(preset) {
+    return isPresetName(preset) ? PRESETS[preset].ompMode : "yolo";
+}
+/**
+ * The default preset for FUTURE sessions, as the permission service
+ * resolves it (settings-backed; the profile patch pins the base default).
+ * Undefined when the service is absent or its getter fails — callers fall
+ * back to OMP's native default.
+ */
+export function defaultPermissionPreset(ctx) {
+    const service = ctx.get("permissionPresets");
+    if (service === undefined)
+        return undefined;
+    try {
+        const preset = service.defaultPreset;
+        return isPresetName(preset) ? preset : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The session's effective preset: the last `permission/preset` event. */
+export function presetFromEvents(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.type === "permission/preset" && isPresetName(event.data?.preset))
+            return event.data.preset;
+    }
+    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
+ * them so the UI shows the session's permission after wrapper restarts.
+ */
+export function permissionEventsFor(preset, time) {
+    const spec = PRESETS[preset];
+    return [
+        { type: "permission/preset", time, data: { preset } },
+        { type: "sandbox/mode", time, data: { mode: spec.sandbox } },
+        { type: "approval/policy", time, data: { policy: spec.approval } },
+    ];
+}
+/**
+ * The bridge's legacy per-session artifact path (the migration reads this to
+ * import the old `dashSessionId` / `permissionPreset` once). Kept read-only;
+ * nothing writes it after the migration.
+ */
+export function webuiArtifactPath(sessionFile) {
+    const base = sessionFile.split("/").pop() ?? sessionFile;
+    const stem = base.endsWith(".jsonl") ? base.slice(0, -".jsonl".length) : base;
+    return join(dirname(sessionFile), stem, "webui.json");
+}

package/agent-omp-sdk/dist/protocol.d.ts

@@ -0,0 +1,189 @@
+/**
+ * agent-omp sidecar protocol (v0).
+ *
+ * Transport: JSON lines over stdio of the bun sidecar process.
+ *  - Node → sidecar: request  frame  { id, method, params }
+ *  - sidecar → Node: response frame  { id, ok: true, result } | { id, ok: false, error }
+ *  - sidecar → Node: event     frame  { event: "<channel>", sessionId?, payload }
+ *  - Node → sidecar: notification    { method, params }  (no id, no response — e.g. session.prompt cancel is out of band via abort)
+ *
+ * Handshake: on start the sidecar pushes { event: "ready", payload: { protocol: 0, sdk: <version> } }.
+ * Every request gets exactly one response, in any order (correlate by id).
+ */
+export declare const PROTOCOL_VERSION = 0;
+export interface RequestFrame {
+    id: number;
+    method: string;
+    params?: unknown;
+}
+export interface NotificationFrame {
+    method: string;
+    params?: unknown;
+}
+export type ResponseFrame = {
+    id: number;
+    ok: true;
+    result: unknown;
+} | {
+    id: number;
+    ok: false;
+    error: string;
+};
+export interface EventFrame {
+    event: string;
+    sessionId?: string;
+    payload: unknown;
+}
+export declare namespace methods {
+    interface PingParams {
+    }
+    interface PingResult {
+        pong: true;
+        sdk: string;
+        bun: string;
+    }
+    interface ModelsListParams {
+        refresh?: boolean;
+    }
+    interface ModelsListResult {
+        models: Array<{
+            provider: string;
+            id: string;
+            name?: string;
+            api?: string;
+            baseUrl?: string;
+            reasoning?: boolean;
+            input?: string[];
+            contextWindow?: number;
+            maxTokens?: number;
+            thinking?: {
+                mode?: string;
+                efforts?: string[];
+                defaultLevel?: string;
+            };
+        }>;
+        providers: string[];
+    }
+    interface SettingsGetParams {
+        key?: string;
+    }
+    interface SettingsGetResult {
+        value: unknown;
+    }
+    /** modelRoles: role → "provider/model[:effort]" selector map. */
+    interface SettingsModelRolesGetParams {
+    }
+    interface SettingsModelRolesGetResult {
+        modelRoles: Record<string, string>;
+    }
+    interface SettingsModelRolesSetParams {
+        modelRoles: Record<string, string>;
+    }
+    interface SettingsModelRolesSetResult {
+        ok: boolean;
+    }
+    interface SessionCreateParams {
+        /** in-memory by default; "file" = SessionManager.create(cwd) */
+        persistence?: "memory" | "file";
+        cwd?: string;
+        /** provider/model selector, resolved the same way the CLI does */
+        model?: string;
+        systemPrompt?: string;
+        appendSystemPrompt?: string;
+    }
+    interface SessionCreateResult {
+        sessionId: string;
+        sessionFile?: string;
+        model?: string;
+    }
+    interface SessionDisposeParams {
+        sessionId: string;
+    }
+    interface SessionDisposeResult {
+        disposed: true;
+    }
+    interface SessionInfoParams {
+        sessionId: string;
+    }
+    interface SessionInfoResult {
+        sessionId: string;
+        sessionFile?: string;
+        model?: string;
+        thinkingLevel?: string;
+        isStreaming: boolean;
+        messageCount: number;
+        /** rendered system prompt (lazy — may be short until first turn) */
+        systemPromptBytes: number;
+    }
+    interface SessionPromptParams {
+        sessionId: string;
+        text: string;
+        streamingBehavior?: "steer" | "followUp";
+    }
+    interface SessionPromptResult {
+        accepted: boolean;
+    }
+    interface SessionSteerParams {
+        sessionId: string;
+        text: string;
+    }
+    interface SessionFollowUpParams {
+        sessionId: string;
+        text: string;
+    }
+    interface SessionAbortParams {
+        sessionId: string;
+    }
+    /** A5 — session store index */
+    interface SessionsListParams {
+        cwd?: string;
+        all?: boolean;
+    }
+    interface SessionsListResult {
+        sessions: Array<{
+            id: string;
+            file: string;
+            title?: string;
+            timestamp?: string;
+        }>;
+    }
+    /** S-lane — rendered base system prompt (live handle + cold file). */
+    interface SessionSystemPromptResult {
+        systemPrompt: string;
+    }
+    interface SessionSystemPromptForFileParams {
+        file: string;
+    }
+    /** A6 — full-library native session index (one `SessionManager.listAll` over every cwd group). */
+    interface SessionsListAllParams {
+    }
+    interface SessionsListAllResult {
+        sessions: Array<{
+            id: string;
+            file: string;
+            cwd?: string;
+            title?: string;
+            /** first user-message text (title fallback source). */
+            firstMessage?: string;
+            /** epoch ms (session header timestamp). */
+            createdAt?: number;
+            /** epoch ms (transcript mtime, ms precision). */
+            mtimeMs?: number;
+            /** transcript byte size. */
+            size?: number;
+        }>;
+    }
+    /** A6 — read-only transcript extraction for one session file (resume/replay). */
+    interface SessionsMessagesReadOnlyParams {
+        file: string;
+    }
+    interface SessionsMessagesReadOnlyResult {
+        messages: unknown[];
+        modelChanges: Array<{
+            model: string;
+            role?: string;
+        }>;
+    }
+}
+/** event channels forwarded from AgentSession.subscribe */
+export type SessionEventChannel = "session:event";

package/agent-omp-sdk/dist/rpc-types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * OMP wire-shape types, shared verbatim with the RPC line
+ * (apps/omp-web/src/rpc.ts) so both clients speak identical payload shapes.
+ */
+/** A `response` record (command acknowledgement). */
+export interface RpcResponse {
+    id?: string;
+    type: "response";
+    command: string;
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+/** Any event record streamed from OMP. */
+export interface RpcEvent {
+    type: string;
+    [key: string]: unknown;
+}
+/** One content block inside an OMP `AgentMessage`. */
+export interface OmpContentBlock {
+    type: string;
+    [key: string]: unknown;
+}
+/** An OMP `AgentMessage` (user | assistant | toolResult). */
+export interface OmpMessage {
+    role: "user" | "assistant" | "toolResult";
+    content?: OmpContentBlock[];
+    [key: string]: unknown;
+}
+/** The `assistantMessageEvent` delta carried by a `message_update` event. */
+export interface OmpAssistantMessageEvent {
+    type: string;
+    contentIndex?: number;
+    delta?: string;
+    content?: string;
+    partial?: unknown;
+    toolCall?: unknown;
+}
+/** The `get_state` response payload. */
+export interface OmpState {
+    isStreaming: boolean;
+    sessionId?: string;
+    sessionFile?: string;
+    /** The currently selected model (`get_state` returns the full model record). */
+    model?: {
+        id: string;
+        provider: string;
+        name?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+/** The `get_session_stats` response payload (live sessions only). */
+export interface OmpSessionStats {
+    tokens?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+    };
+    contextUsage?: number;
+    cost?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * An OMP `extension_ui_request` record. Approval cards surface as
+ * `method: "select"` with `options: ["Approve", "Deny"]`; the client answers
+ * with an `extension_ui_response` echoing the request `id` and a `value`.
+ */
+export interface RpcExtensionUiRequest {
+    type: "extension_ui_request";
+    id: string;
+    method: string;
+    title?: string;
+    options?: string[];
+    [key: string]: unknown;
+}

package/agent-omp-sdk/dist/rpc-types.js

@@ -0,0 +1 @@
+export {};