super-dsh 0.1.0 → 0.1.2

package/agent-claude/dist/interaction.js

@@ -0,0 +1,271 @@
+/**
+ * The interaction bridge (plan Task 8): Claude Code's three human-interaction
+ * callbacks mapped onto DSH's two native human-interaction seams.
+ *
+ * Claude Code routes every human decision through exactly three SDK callbacks —
+ * `canUseTool` (tool permission), the `AskUserQuestion` tool, and
+ * `ExitPlanMode` (plan approval) — while DSH exposes exactly two native
+ * interaction waterfalls and **no generic extension-UI seam**. So all three
+ * Claude callbacks must be expressed through those two:
+ *
+ * - tool permission → `ctx.approval.request()`, whose closed outcome union is
+ *   `"allowed-once" | "rejected" | "cancelled" | "unavailable"`;
+ * - `AskUserQuestion` → `ctx.userQuestions.ask()`, returning the same
+ *   `{ answers: [{ id, selected, custom? }] }` batch shape;
+ * - plan approval → **the same** `ask()` seam, distinguished by an
+ *   `intent: { kind: "plan-review", approve }` on the question.
+ *
+ * **Fail-closed is the contract.** `"allowed-once"` is the only outcome that
+ * grants anything: every other outcome, every thrown/rejected promise, and
+ * every malformed response becomes `{ behavior: "deny", message }` (or `false`
+ * for {@link askPlanReview}) — never `allow`, never a silent pass.
+ *
+ * The module is **pure and type-only**: it imports nothing at all (not the
+ * Claude SDK, not Cordis) and touches no storage, settings, or session log.
+ * {@link ApprovalLike} / {@link UserQuestionsLike} are the minimal structural
+ * types of the DSH seams, so the real `ctx.approval` / `ctx.userQuestions` are
+ * structurally compatible and are injected later (Task 9). Persisting a
+ * selected permission mode is explicitly **not** this module's concern.
+ */
+/** Narrow an untrusted value to a plain JSON object. */
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Human-readable text for an unknown thrown value (the deny message's trace). */
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** The `canUseTool` denial: the word `denied` keeps every refusal visible. */
+function toolCallDenied(reason) {
+    return { behavior: "deny", message: `Claude Code tool call denied (${reason})` };
+}
+/** The denial reason for an approval outcome or a rogue value. */
+function outcomeReason(outcome) {
+    return typeof outcome === "string" ? outcome : "unrecognized approval outcome";
+}
+/**
+ * Map Claude Code's `canUseTool` callback onto `ctx.approval.request()`.
+ *
+ * The returned callback is the SDK's fail-closed permission gate:
+ *
+ * - `"allowed-once"` → `{ behavior: "allow" }` (the input is never rewritten —
+ *   the tool call proceeds with the arguments Claude already supplied);
+ * - `"rejected"` / `"cancelled"` / `"unavailable"` / anything else → deny;
+ * - a rejected `approval.request` promise (an idle turn, a failed audit append,
+ *   a missing answerer that throws instead of normalizing) → deny.
+ *
+ * The approval request carries `toolName` and `callId` (from
+ * `options.toolUseID`) so the DSH UI attaches the prompt to the tool call it
+ * already streamed; the arguments are deliberately *not* duplicated here,
+ * which is why `input` is unused.
+ *
+ * @param deps - the approval seam and the agent asking.
+ * @returns a `CanUseTool`-compatible callback.
+ */
+export function makeCanUseTool(deps) {
+    return async (toolName, _input, options) => {
+        let outcome;
+        try {
+            outcome = await deps.approval.request({
+                agent: deps.agent,
+                toolName,
+                callId: options?.toolUseID,
+                ...(options?.decisionReason !== undefined ? { reason: options.decisionReason } : {}),
+                signal: options?.signal,
+            });
+        }
+        catch (error) {
+            return toolCallDenied(`the approval request failed: ${errorText(error)}`);
+        }
+        // Exact-match grant: a rogue or missing value must never open the gate.
+        if (outcome === "allowed-once")
+            return { behavior: "allow" };
+        return toolCallDenied(outcomeReason(outcome));
+    };
+}
+/** True when one untrusted answer entry is a well-formed {@link AskAnswerItem}. */
+function isAnswerItem(value) {
+    return isRecord(value)
+        && typeof value.id === "string"
+        && Array.isArray(value.selected)
+        && value.selected.every((label) => typeof label === "string")
+        && (value.custom === undefined || typeof value.custom === "string");
+}
+/**
+ * Resolve the answer entry for one converted question by **id only**.
+ *
+ * The DSH service echoes the id it was given, so an id match is the one proof
+ * that an answer belongs to this question. There is deliberately **no**
+ * positional fallback: a response of the right length but with foreign or
+ * mismatched ids (a reordered batch, a foreign answerer, a test double) would
+ * otherwise pair `answers[i]` with `questions[i]` and silently feed Claude
+ * somebody else's answer. Such a response fails closed instead, as does a
+ * missing/empty/non-array `answers` or any entry that is not a well-formed
+ * {@link AskAnswerItem}.
+ *
+ * @param answer - the untrusted response from `ask()`.
+ * @param question - the question being resolved.
+ * @returns the matching answer entry, or undefined when the response cannot
+ *   answer this question.
+ */
+function resolveAnswer(answer, question) {
+    if (!isRecord(answer) || !Array.isArray(answer.answers))
+        return undefined;
+    if (!answer.answers.every(isAnswerItem))
+        return undefined;
+    return answer.answers.find((item) => item.id === question.id);
+}
+/**
+ * Encode one question's answer the way Claude's `answers` map wants it:
+ * multi-select labels joined by `", "`, then the custom "Other" text appended
+ * as one more comma-separated segment. Neither an absent/blank `custom` nor an
+ * empty `selected` may leave a stray or doubled `", "`.
+ */
+function encodeAnswer(selected, custom) {
+    const segments = [];
+    if (selected.length > 0)
+        segments.push(selected.join(", "));
+    const extra = typeof custom === "string" ? custom.trim() : "";
+    if (extra !== "")
+        segments.push(extra);
+    return segments.join(", ");
+}
+/** Claude's `AskUserQuestionInput` question list, narrowed to a usable array. */
+function claudeQuestions(input) {
+    return isRecord(input) && Array.isArray(input.questions) ? input.questions : [];
+}
+/** Convert one Claude question into the DSH ask item, or undefined when unusable. */
+function toAskQuestion(raw, index) {
+    if (!isRecord(raw) || typeof raw.question !== "string" || raw.question === "")
+        return undefined;
+    const options = Array.isArray(raw.options)
+        ? raw.options.flatMap((option) => {
+            if (!isRecord(option) || typeof option.label !== "string")
+                return [];
+            return [{
+                    label: option.label,
+                    ...(typeof option.description === "string" ? { description: option.description } : {}),
+                }];
+        })
+        : [];
+    const multiSelect = typeof raw.multiSelect === "boolean" ? raw.multiSelect : undefined;
+    return {
+        id: `q${index}`,
+        question: raw.question,
+        ...(typeof raw.header === "string" ? { header: raw.header } : {}),
+        ...(options.length > 0 ? { options } : {}),
+        // The service contract's own spelling — the only one the seam reads.
+        ...(multiSelect !== undefined ? { multiSelect } : {}),
+    };
+}
+/**
+ * Map Claude Code's `AskUserQuestion` tool call onto `ctx.userQuestions.ask()`
+ * and translate the human's answer back into Claude's `updatedInput.answers`.
+ *
+ * The batch is converted per question: a fresh DSH id (`q${i}`), the question
+ * text, the header when present, the option labels/descriptions (Claude's
+ * UI-only `preview` is dropped — DSH has no field for it), and the multi-select
+ * flag. The answer comes back keyed by the **question text** (Claude's `answers`
+ * is `{ [questionText]: string }`), each value being the selected labels joined
+ * by `", "` with any custom "Other" text appended as one more segment.
+ *
+ * Fail-closed: a missing/empty/malformed question batch, a rejected `ask()`
+ * promise, a malformed answer batch, and any unanswered question all produce
+ * `{ behavior: "deny", message }`. A question *without* options is legitimate
+ * (DSH renders it as a free-text answer) and is asked with no option menu.
+ *
+ * @param deps - the user-questions seam and the agent asking.
+ * @param input - Claude's `AskUserQuestionInput` (its `questions` array is input).
+ * @param signal - the tool call's cancellation lifetime.
+ * @returns an allow carrying `updatedInput` with the `answers` map, or a denial.
+ */
+export async function answerAskUserQuestion(deps, input, signal) {
+    const raw = claudeQuestions(input);
+    if (raw.length === 0) {
+        // Nothing to ask is malformed input (the seam itself rejects it as
+        // EMPTY_QUESTIONS); fabricating an empty answer set would hand Claude a
+        // result no human produced.
+        return { behavior: "deny", message: "Claude Code AskUserQuestion denied (no questions to ask)" };
+    }
+    const questions = [];
+    for (let index = 0; index < raw.length; index += 1) {
+        const question = toAskQuestion(raw[index], index);
+        if (question === undefined) {
+            return {
+                behavior: "deny",
+                message: `Claude Code AskUserQuestion denied (question ${index} is malformed)`,
+            };
+        }
+        questions.push(question);
+    }
+    let answer;
+    try {
+        answer = await deps.questions.ask({
+            questions,
+            agent: deps.agent,
+            signal,
+        });
+    }
+    catch (error) {
+        return {
+            behavior: "deny",
+            message: `Claude Code AskUserQuestion denied (the user-question request failed: ${errorText(error)})`,
+        };
+    }
+    const answers = {};
+    for (let index = 0; index < questions.length; index += 1) {
+        const question = questions[index];
+        const item = resolveAnswer(answer, question);
+        if (item === undefined) {
+            return {
+                behavior: "deny",
+                message: `Claude Code AskUserQuestion denied (no answer for question ${question.id})`,
+            };
+        }
+        answers[question.question] = encodeAnswer(item.selected, item.custom);
+    }
+    return { behavior: "allow", updatedInput: { ...input, answers } };
+}
+/** The DSH question id the plan review asks under (and answers by). */
+const PLAN_QUESTION_ID = "plan";
+/** The option label that approves the plan. */
+const PLAN_APPROVE_LABEL = "Approve";
+/** The option label that declines the plan. */
+const PLAN_DECLINE_LABEL = "Keep planning";
+/**
+ * Map Claude Code's `ExitPlanMode` callback onto the **same**
+ * `ctx.userQuestions.ask()` seam, tagged for plan-review presentation.
+ *
+ * The question carries `detail = plan`, the binary Approve/Keep-planning option
+ * pair, and `intent: { kind: "plan-review", approve: "Approve" }` — the intent's
+ * `approve` names one of the question's own options, as `ask()` requires. Only
+ * an answer whose `selected` contains `"Approve"` approves; every other answer,
+ * a rejected `ask()` promise, a missing/malformed answer, and any thrown error
+ * return `false` (fail-closed: declining keeps the plan unapproved).
+ *
+ * @param deps - the user-questions seam and the agent asking.
+ * @param plan - the plan markdown under review.
+ * @param signal - the call's cancellation lifetime.
+ * @returns true only when the human approved.
+ */
+export async function askPlanReview(deps, plan, signal) {
+    const question = {
+        id: PLAN_QUESTION_ID,
+        question: "Approve this plan?",
+        detail: plan,
+        options: [{ label: PLAN_APPROVE_LABEL }, { label: PLAN_DECLINE_LABEL }],
+        intent: { kind: "plan-review", approve: PLAN_APPROVE_LABEL },
+    };
+    try {
+        const answer = await deps.questions.ask({
+            questions: [question],
+            agent: deps.agent,
+            signal,
+        });
+        const item = resolveAnswer(answer, question);
+        return item !== undefined && item.selected.includes(PLAN_APPROVE_LABEL);
+    }
+    catch {
+        return false;
+    }
+}

package/agent-claude/dist/models.js

@@ -0,0 +1,158 @@
+/**
+ * Claude model catalog for the Dash model selector.
+ *
+ * Claude owns the truth about which models exist. Sources, in authority
+ * order:
+ * - the boot probe (`probeClaudeModels`, claude-client.ts): one ephemeral SDK
+ *   query at provider boot asks the CLI's `supportedModels()` and publishes
+ *   the full alias roster (sonnet/opus/haiku/fable/...) via
+ *   {@link setModelCatalog};
+ * - the live session's `supportedModels()` (agent.ts), which overwrites the
+ *   same catalog once a session is running;
+ * - until the first probe answer, the degraded single-entry catalog derived
+ *   from the runtime's own `session_init.model` (`catalogFromInit`).
+ *
+ * This module is only the in-memory projection those observations are
+ * published into — the browser model selector reads it through
+ * `ClaudeLlmAdapter` under the `claude` route.
+ *
+ * Observed-only (the invariant this file exists to hold):
+ * - Nothing here ever synthesises a placeholder model id (`claude-default`,
+ *   a `deepseek-flash` fallback, ...), because a fabricated id would leak
+ *   into the picker and onto the wire.
+ * - `CLAUDE_DEFAULT_MODEL` is a REAL CLI alias kept ONLY as the boot/fallback
+ *   default (and the probe-failure catalog): every other entry must come from
+ *   a runtime observation. A degraded value stays in memory — it is never
+ *   written to settings, and only the alias the CLI itself resolves ever
+ *   reaches the runtime as a selection.
+ *
+ * The catalog is process-global module state, not a per-adapter instance
+ * field: exactly one Claude app per world observes it, and the settings-UI
+ * round trip constructs its own adapter instance.
+ */
+/** The empty catalog after a legitimate empty observation (`setModelCatalog([])`). */
+const EMPTY_CATALOG = Object.freeze({ models: Object.freeze([]) });
+/**
+ * The ONE real model this adapter is configured to use at boot: the Claude
+ * Code model alias `sonnet` (a genuine CLI-resolvable id, never a fabricated
+ * placeholder). It names the BOOT catalog row and the fallback default used
+ * when neither the boot probe nor a live session has answered — a probe
+ * failure must never grow fabricated rows, only keep this one real alias.
+ */
+export const CLAUDE_DEFAULT_MODEL = "sonnet";
+/** The boot catalog: the declared default, served before any observation. */
+const BOOT_CATALOG = Object.freeze({
+    models: Object.freeze([Object.freeze({ id: CLAUDE_DEFAULT_MODEL, label: CLAUDE_DEFAULT_MODEL })]),
+    defaultModel: CLAUDE_DEFAULT_MODEL,
+});
+let catalog = BOOT_CATALOG;
+/** Detach one entry so neither side of a read/write can mutate the other. */
+function cloneEntry(entry) {
+    return {
+        id: entry.id,
+        label: entry.label,
+        ...(entry.description === undefined ? {} : { description: entry.description }),
+        ...(entry.contextWindow === undefined ? {} : { contextWindow: entry.contextWindow }),
+        ...(entry.resolvedModel === undefined ? {} : { resolvedModel: entry.resolvedModel }),
+        ...(entry.reasoningEfforts === undefined ? {} : { reasoningEfforts: Object.freeze([...entry.reasoningEfforts]) }),
+    };
+}
+/** A detached entry that neither side of a read/write can mutate. */
+function frozenEntry(entry) {
+    return Object.freeze(cloneEntry(entry));
+}
+/**
+ * Publish the observed catalog. This is an **overwrite**, never a merge:
+ * calling it twice leaves only the second list, so the catalog can shrink
+ * (including back to empty) when Claude reports fewer models.
+ *
+ * Entries are copied in, so a caller mutating its own array afterwards cannot
+ * reach back into module state.
+ *
+ * @param entries - exactly the models Claude reported; `[]` is a legitimate
+ *   observation and must never be replaced by a placeholder.
+ * @param defaultModel - the model Claude named as default. It is stored only
+ *   when it is non-empty **and** names one of `entries`: a dangling default
+ *   would render as a selection the picker cannot show and `resolveModel`
+ *   cannot resolve, which is the same fabricated reference onto the wire that
+ *   a placeholder model id would be.
+ */
+export function setModelCatalog(entries, defaultModel) {
+    catalog = Object.freeze({
+        models: Object.freeze(entries.map(frozenEntry)),
+        ...(defaultModel !== undefined && defaultModel !== "" && entries.some((entry) => entry.id === defaultModel)
+            ? { defaultModel }
+            : {}),
+    });
+}
+/**
+ * Read the current catalog as a detached, frozen snapshot: a caller cannot
+ * mutate module state through it, nor observe a later write through it.
+ */
+export function readModelCatalog() {
+    if (catalog.models.length === 0 && catalog.defaultModel === undefined)
+        return EMPTY_CATALOG;
+    return Object.freeze({
+        models: Object.freeze(catalog.models.map(frozenEntry)),
+        ...(catalog.defaultModel === undefined ? {} : { defaultModel: catalog.defaultModel }),
+    });
+}
+/**
+ * Derive the **degraded** single-entry catalog from a projected `session_init`
+ * (Task 4) while `supportedModels()` has not answered yet.
+ *
+ * The runtime's own reported model is real, so it may stand in for the catalog
+ * until the authoritative list arrives. It is a read of memory only: callers
+ * must not persist it into settings, and must not pass it back to the runtime
+ * as a selection.
+ *
+ * @param init - the projected `session_init` shape; anything unusable —
+ *   non-string, empty, or whitespace-only — yields `[]` (still empty — no
+ *   placeholder).
+ * @returns zero or one observed entry.
+ */
+export function catalogFromInit(init) {
+    const model = init?.model;
+    if (typeof model !== "string" || model.trim() === "")
+        return [];
+    return [{ id: model, label: model }];
+}
+/**
+ * Map one SDK `ModelInfo` row onto a Dash {@link ClaudeModelEntry} (skip
+ * unusable rows). Lives here so both the boot probe (index.ts) and the live
+ * session observation (agent.ts) project rows through ONE mapping.
+ */
+export function modelEntryFromSdk(raw) {
+    if (raw === null || typeof raw !== "object")
+        return [];
+    const m = raw;
+    const id = typeof m.value === "string" && m.value !== "" ? m.value : undefined;
+    if (id === undefined)
+        return [];
+    const label = typeof m.displayName === "string" && m.displayName !== "" ? m.displayName : id;
+    // The alias's canonical wire id is appended to the description, never the
+    // id itself: the picker selects by the CLI alias (the wire contract).
+    const resolved = typeof m.resolvedModel === "string" && m.resolvedModel !== "" && m.resolvedModel !== id
+        ? m.resolvedModel
+        : undefined;
+    const base = typeof m.description === "string" && m.description !== "" ? m.description : undefined;
+    const description = resolved === undefined
+        ? base
+        : base === undefined
+            ? `resolves to ${resolved}`
+            : `${base} (resolves to ${resolved})`;
+    // `supportedEffortLevels` → adapter reasoning efforts (omp thinking.efforts
+    // parity); the CLI names no per-model default, so none is invented.
+    const levels = Array.isArray(m.supportedEffortLevels) ? m.supportedEffortLevels : [];
+    const efforts = [];
+    for (const level of levels) {
+        if (typeof level === "string" && level !== "" && !efforts.includes(level))
+            efforts.push(level);
+    }
+    return [{
+            id,
+            label,
+            ...(description === undefined ? {} : { description }),
+            ...(efforts.length === 0 ? {} : { reasoningEfforts: Object.freeze(efforts) }),
+        }];
+}

package/agent-claude/dist/permission.js

@@ -0,0 +1,120 @@
+/**
+ * The 3-preset skeleton → Claude mode table. Typed as an exhaustive record, so
+ * adding a {@link PresetName} without a mapping is a compile error.
+ */
+export const PRESET_TO_CLAUDE = Object.freeze({
+    "read-only": "default",
+    "workspace-write": "acceptEdits",
+    "danger-full-access": "bypassPermissions",
+});
+/**
+ * Claude-only tiers that sit ON TOP of the skeleton. Ordered as the UI lists
+ * them. None of these is a DSH preset name — `Object.values(PRESET_TO_CLAUDE)`
+ * must never contain one.
+ */
+export const EXTRA_TIERS = Object.freeze(["plan", "auto", "dontAsk"]);
+/**
+ * The Dash sandbox + approval each skeleton preset composes (the profile pins
+ * the same table in its `permission` row). Claude's own mode rides alongside;
+ * these two events are the DSH-side facts the UI folds.
+ */
+const DSH_SKELETON = {
+    "read-only": { sandbox: "read-only", approval: "ask" },
+    "workspace-write": { sandbox: "workspace-write", approval: "ask" },
+    "danger-full-access": { sandbox: "danger-full-access", approval: "never" },
+};
+/** Narrow an untrusted value to a known DSH preset name. */
+export function isPresetName(raw) {
+    return typeof raw === "string" && Object.hasOwn(PRESET_TO_CLAUDE, raw);
+}
+/**
+ * Map a DSH preset name **or** an {@link EXTRA_TIERS} tier onto the Claude
+ * permission mode it selects. An extra tier is already Claude vocabulary and
+ * passes through; anything unknown — including `undefined` — degrades to
+ * `"default"`, the most restrictive skeleton mode.
+ */
+export function claudePermissionMode(preset) {
+    if (preset === "plan" || preset === "auto" || preset === "dontAsk")
+        return preset;
+    return isPresetName(preset) ? PRESET_TO_CLAUDE[preset] : "default";
+}
+/**
+ * Inverse of {@link PRESET_TO_CLAUDE}: the DSH skeleton preset whose Claude
+ * mode this is, or undefined for the {@link EXTRA_TIERS} (`plan` / `auto` /
+ * `dontAsk`) — they are mode-only runtime state with no DSH preset of their
+ * own, so a live mode change to one of them must NOT rewrite the recorded
+ * preset. Used by `onModeChange` to upsert `{claudeMode, preset}` TOGETHER.
+ */
+export function presetFromClaudeMode(mode) {
+    for (const [preset, mapped] of Object.entries(PRESET_TO_CLAUDE)) {
+        if (mapped === mode)
+            return preset;
+    }
+    return undefined;
+}
+/**
+ * The session-record patch a live mode change persists (RC-5): the mode
+ * always rides along, and the preset TOGETHER with it whenever the mode is a
+ * skeleton image — an extra tier (`plan` / `auto` / `dontAsk`) changes the
+ * mode only, leaving the recorded preset untouched. `onModeChange` feeds
+ * this straight into `upsertSession`.
+ */
+export function modeChangePatch(mode) {
+    const preset = presetFromClaudeMode(mode);
+    return { claudeMode: mode, ...(preset === undefined ? {} : { preset }) };
+}
+/**
+ * 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 the most
+ * restrictive Claude mode.
+ */
+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 DSH preset: the last revivable `permission/preset`
+ * event.
+ *
+ * Only the 3-preset skeleton round-trips here: an {@link EXTRA_TIERS} tier is
+ * not a preset name, so an event carrying `preset: "plan"` is skipped. Extra
+ * tiers are Claude-side runtime state (switchable via `setPermissionMode`), not
+ * DSH presets — they are read back through {@link claudePermissionMode} and the
+ * event's `claudeMode` field, never promoted to a second event type.
+ */
+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;
+}
+/**
+ * The DSH permission events stamped for a session's preset, in append order
+ * (preset, sandbox, approval) — the same shape `agent-codex/src/permission.ts`
+ * emits. The first event additionally carries `claudeMode`: the effective
+ * Claude permission mode the live `setPermissionMode` call and the UI both
+ * read from one place.
+ *
+ * The parameter is a {@link PresetName} on purpose. `plan` / `auto` / `dontAsk`
+ * are not DSH presets and have no sandbox/approval skeleton to stamp; they
+ * change only the Claude-side mode at runtime.
+ */
+export function permissionEventsFor(preset, time) {
+    const spec = DSH_SKELETON[preset];
+    return [
+        { type: "permission/preset", time, data: { preset, claudeMode: claudePermissionMode(preset) } },
+        { type: "sandbox/mode", time, data: { mode: spec.sandbox } },
+        { type: "approval/policy", time, data: { policy: spec.approval } },
+    ];
+}

package/agent-claude/dist/session-id.js

@@ -0,0 +1,20 @@
+/**
+ * DSH session id <-> Claude session id anchoring (spec ruling R8, route A).
+ *
+ * The DSH id is `<prefix>-<uuid>` (minted by the session store). Claude accepts
+ * any UUID version (its predicate is the version-agnostic regex below, verified
+ * byte-identical in the SDK and the CLI). So we preset Claude's sessionId from
+ * the DSH id's UUID tail: no mapping file, and the id survives restarts.
+ *
+ * Route B (SDK-minted id + a persisted map) is the fallback ONLY for a DSH id
+ * that is not a UUID; the caller must trace it, never fall back silently.
+ */
+export const CLAUDE_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function isClaudeSessionId(value) {
+    return typeof value === "string" && CLAUDE_SESSION_ID_RE.test(value);
+}
+/** UUID tail of a DSH session id, or `undefined` when it is not a UUID. */
+export function claudeSessionIdFromDsh(dshSessionId) {
+    const tail = dshSessionId.replace(/^session-/, "");
+    return isClaudeSessionId(tail) ? tail.toLowerCase() : undefined;
+}