@comecaramelos/dsh-chrome-mcp 0.0.1 → 2.0.0

package/lib/host/types/config.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Types — the config `apply` receives, and the plugin context.
+ *
+ * One `Config` (./../schema.ts) carries everything: the ordinary row-config
+ * fields the card only reads, the user-authored fields the card edits, and the
+ * live answers the Host publishes. What matters to every consumer here is the
+ * *shape at runtime*: dsh 0.2.0 hands `apply` a reference for every
+ * `.volatile()` field and a plain value for every ordinary one, so reading a
+ * volatile field's type is not reading what it holds (see ./values.ts
+ * `readConfigField`). The two halves are typed apart for exactly that reason.
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { BridgeStderrMode } from "./stderr.js";
+import type { ChromeExecutableEntry, ChromeExecutableStatus, EffectiveChromeSource } from "./executable.js";
+import type { WindowsChromeStatus } from "./windows.js";
+/** A `.volatile()` field as `apply` hands it: a stable reference the fiber
+ * resolves live, or — the shape a hand-built config (or a test) hands — the plain
+ * value itself. Read it through `readConfigField` (./values.ts). */
+export type ConfigField<T> = T | {
+    get(): T;
+};
+/**
+ * The validated row config as `apply` sees it: every ordinary field resolved to
+ * its final shape (the card reads them, it never edits them), every `.volatile()`
+ * field as a reference. This is the one config type the host half passes around —
+ * `buildServerArgs`, `checkChrome` and the bridge config all read ordinary
+ * fields directly and take the volatile ones through `readConfigField` or an
+ * explicit argument.
+ */
+export type ChromeMcpConfig = {
+    serverName: string;
+    command: string;
+    package: string;
+    chromePaths: string[];
+    env: Record<string, string>;
+    cwd: string;
+    toolCallTimeoutMs: number;
+    /** Ceiling for the bridge's server instructions, in UTF-8 bytes (attribution
+     * included). A verbatim passthrough to the nested `dsh-mcp-client` row; a
+     * server whose instructions exceed it never connects. */
+    maxInstructionBytes: number;
+    failOnStartupError: boolean;
+    reconnect: ReconnectConfig;
+    /** Bridge console-output routing: "log" (default) redirects the child's
+     * stderr into a log file; "console" echoes it. The card's "Reduce log
+     * output" toggle (`stderrMode`) overrides this. */
+    bridgeStderr: BridgeStderrMode;
+    /** Optional absolute path for the stderr log ("" → the private per-process
+     * directory created by `mkdtemp`, holding `<serverName>-bridge.log`). */
+    bridgeStderrLog: string;
+    extraFlags: ConfigField<string[]>;
+    /** The executable the bridge launches with: a saved row's path the picker
+     * wrote, or one the Host seeded once. "" = nothing resolved yet. */
+    chromePath: ConfigField<string>;
+    /** The picker's saved rows, `{ id: path, name: label }`. */
+    executables: ConfigField<ChromeExecutableEntry[]>;
+    /** The ids of saved rows the user dropped — Host-authored, consulted by
+     * every merge step so a deleted row never comes back. */
+    droppedExecutables: ConfigField<string[]>;
+    /** **Legacy** MRU of hand-typed executables — read once, never written. */
+    chromeCustomPaths: ConfigField<string[]>;
+    /** The card's stderr toggle: "log"/"console"/"" (follow `bridgeStderr`). */
+    stderrMode: ConfigField<"" | BridgeStderrMode>;
+    /** The card's **Fetch executables** trigger. */
+    refreshExecutablesNonce: ConfigField<number>;
+    /** The card's **Prelaunch Windows Chrome** trigger. */
+    openWindowsChromeNonce: ConfigField<number>;
+    lastError: ConfigField<string>;
+    chromeMissing: ConfigField<boolean>;
+    executableDiscoveryRevision: ConfigField<number>;
+    chromeVersion: ConfigField<string>;
+    executableStatus: ConfigField<ChromeExecutableStatus[]>;
+    effectiveChromePath: ConfigField<string>;
+    effectiveSource: ConfigField<EffectiveChromeSource>;
+    stderrEffective: ConfigField<BridgeStderrMode>;
+    defaultExtraFlags: ConfigField<string[]>;
+    wslExtraFlags: ConfigField<string[]>;
+    wslWindowsExecutable: ConfigField<boolean>;
+    windowsChromeStatus: ConfigField<WindowsChromeStatus>;
+    carriesConnectionMode: ConfigField<boolean>;
+    /** The flags the live connection actually launches with (mirrored from the
+     * last resolve). */
+    runningFlags: ConfigField<string[]>;
+    /** The note the live connection answered with. */
+    runningNote: ConfigField<string>;
+    /** Whether the standalone-config translation was turned down (D4). */
+    migrationDismissed: ConfigField<boolean>;
+};
+/** Reconnect policy, mirroring the `dsh-mcp-client` bridge config. */
+export type ReconnectConfig = {
+    enabled: boolean;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    maxAttempts: number;
+};
+/**
+ * Plugin context as consumed by this host half. `ctx.effect`, `ctx.inject`,
+ * `ctx.plugin`, and `ctx.get` all come from cordis `Context` itself.
+ */
+export type PluginContext = Context;
+//# sourceMappingURL=config.d.ts.map

package/lib/host/types/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/host/types/config.ts"],"names":[],"mappings":"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"}

package/lib/host/types/config.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.js.map

package/lib/host/types/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../src/host/types/config.ts"],"names":[],"mappings":""}

package/lib/host/types/executable.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Types — the saved-executable rows and where the effective selection came from.
+ *
+ * The picker's catalog shape (the rows the card edits and a merged run extends)
+ * plus the per-path probe answer and the source tag, split out of the single
+ * `types.ts`.
+ */
+/**
+ * One saved-executable catalog row: `id` is the path the bridge launches with,
+ * `name` the label the user chose for the UI ("" = render the path). Persisted —
+ * the reference plugin's executables catalog, same split.
+ */
+export type ChromeExecutableEntry = {
+    id: string;
+    name: string;
+};
+/**
+ * What one saved row answered with, keyed by its id: the `--version` line
+ * (`""` when the probe answered nothing), the failure that makes the row not
+ * runnable (`""` when it runs), and the **note** that explains an executable
+ * this host offers without probing it. A note is not a failure: the path is
+ * there and usable, only not launchable *as a local executable* from here — the
+ * one case is a Windows `chrome.exe` on a WSL host, which the **Prelaunch
+ * Windows Chrome** run drives in connect mode. Base-layer status, never
+ * persisted — the rows themselves live in the user layer.
+ */
+export type ChromeExecutableStatus = {
+    path: string;
+    version: string;
+    error: string;
+    note: string;
+};
+/** Where the effective executable came from (`effectiveSource`). */
+export type EffectiveChromeSource = "selected" | "row-config" | "";
+//# sourceMappingURL=executable.d.ts.map

package/lib/host/types/executable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executable.d.ts","sourceRoot":"","sources":["../../../src/host/types/executable.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjE;;;;;;;;;GASG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,oEAAoE;AACpE,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,YAAY,GAAG,EAAE,CAAC"}

package/lib/host/types/executable.js

@@ -0,0 +1,9 @@
+/**
+ * Types — the saved-executable rows and where the effective selection came from.
+ *
+ * The picker's catalog shape (the rows the card edits and a merged run extends)
+ * plus the per-path probe answer and the source tag, split out of the single
+ * `types.ts`.
+ */
+export {};
+//# sourceMappingURL=executable.js.map

package/lib/host/types/executable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executable.js","sourceRoot":"","sources":["../../../src/host/types/executable.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/lib/host/types/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Host-half shared types — the whole surface.
+ *
+ * Everything a module needs without importing its implementation, split into
+ * sections by concern and re-exported here so `from "./types/index.js"` still
+ * names all of it:
+ *
+ *   ./stderr.ts     where the bridge console goes + the stderr-wrapper shapes
+ *   ./config.ts     the config `apply` receives + reconnect + PluginContext
+ *   ./executable.ts the saved-executable rows + source tag
+ *   ./windows.ts    the Prelaunch Windows Chrome run's states + outcome
+ *   ./settings.ts   the configuration form's layers, the live mirror, the service
+ *   ./plugin.ts     the bridge fiber + the tool-call captures
+ *
+ * Structural views stay narrow: only what the host half actually calls.
+ */
+export type { BridgeStderrMode, BridgeStderrNotice, BridgeSpawnTarget, BridgeSpawnOptions, BridgeSpawnResult, BridgeStderrLogPathOptions } from "./stderr.js";
+export type { ChromeMcpConfig, ConfigField, ReconnectConfig, PluginContext } from "./config.js";
+export type { ChromeExecutableEntry, ChromeExecutableStatus, EffectiveChromeSource } from "./executable.js";
+export type { WindowsChromeState, WindowsChromeStatus, WindowsChromeLinkAnswer, WindowsChromeRun } from "./windows.js";
+export type { ConfigUserFields, ConfigLiveFields, ConfigLayerFields, ConfigLayers, SettingsForms, SettingsFormRow, SettingsPathOp, ChromeMcpForm } from "./settings.js";
+export type { McpBridge, ToolCallExecution, ToolCallResult } from "./plugin.js";
+export type { CommandDefinition, CommandInvocation, CommandResult } from "./services.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/host/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/host/types/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,YAAY,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAC9J,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAChG,YAAY,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAC5G,YAAY,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACvH,YAAY,EACR,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,eAAe,EACf,cAAc,EACd,aAAa,EAChB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,SAAS,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAChF,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC"}

package/lib/host/types/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/lib/host/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/host/types/index.ts"],"names":[],"mappings":""}

package/lib/host/types/plugin.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Types — the nested bridge fiber and the tool-call captures.
+ *
+ * The narrow structural views over the two things this host half listens on but
+ * does not own: the `dsh-mcp-client` bridge fiber its flag/executable changes
+ * drive, and the tool-call result/execution the post-execute listener sees. Split
+ * out of the single `types.ts`.
+ */
+/**
+ * Nested `dsh-mcp-client` bridge fiber. `update` is the only method the host
+ * calls, but it is consumed through the fiber's own readiness: cordis restarts
+ * a fiber only while it is ACTIVE, so an update is chained on the settle.
+ */
+export interface McpBridge {
+    update(config: unknown): unknown;
+    /** Cordis `Fiber & PromiseLike<Fiber>`: settles once the fiber does. */
+    then(onFulfilled?: (value: unknown) => unknown, onRejected?: (reason: unknown) => unknown): PromiseLike<unknown>;
+}
+/**
+ * Tool-call result as returned by the MCP tools-service (settled promise).
+ */
+export interface ToolCallResult {
+    isError?: boolean;
+    content?: Array<{
+        type?: string;
+        text?: string;
+    }>;
+    error?: {
+        message?: string;
+    };
+}
+/**
+ * Tool call execution context as received by the post-execute listener.
+ */
+export interface ToolCallExecution {
+    name: string;
+}
+//# sourceMappingURL=plugin.d.ts.map

package/lib/host/types/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/host/types/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACtB,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC;IACjC,wEAAwE;IACxE,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,EAAE,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;CACpH;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClD,KAAK,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAC9B,IAAI,EAAE,MAAM,CAAC;CAChB"}

package/lib/host/types/plugin.js

@@ -0,0 +1,10 @@
+/**
+ * Types — the nested bridge fiber and the tool-call captures.
+ *
+ * The narrow structural views over the two things this host half listens on but
+ * does not own: the `dsh-mcp-client` bridge fiber its flag/executable changes
+ * drive, and the tool-call result/execution the post-execute listener sees. Split
+ * out of the single `types.ts`.
+ */
+export {};
+//# sourceMappingURL=plugin.js.map

package/lib/host/types/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../../src/host/types/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/lib/host/types/services.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Structural views of the host services this half registers onto but does not
+ * own. The slash-command shapes come from the `commands` service — the headless
+ * mirror surface the card's two executable actions get; the service may be
+ * mounted after `apply` returns (hence the lazy injection) and may not be
+ * mounted at all on a host with no commands plane.
+ */
+/** One slash-command invocation: the raw text after the command name. */
+export type CommandInvocation = {
+    rawInput: string;
+};
+/** What a slash-command handler answers with — never thrown, always shown. */
+export type CommandResult = {
+    kind: "success" | "error";
+    text: string;
+};
+/** The `commands` service definition shape, registered by name. */
+export type CommandDefinition = {
+    name: string;
+    description: string;
+    input?: {
+        hint?: string;
+    };
+    handler: (invocation: CommandInvocation) => CommandResult | Promise<CommandResult>;
+};
+//# sourceMappingURL=services.d.ts.map

package/lib/host/types/services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../src/host/types/services.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,yEAAyE;AACzE,MAAM,MAAM,iBAAiB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAErD,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAExE,mEAAmE;AACnE,MAAM,MAAM,iBAAiB,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1B,OAAO,EAAE,CAAC,UAAU,EAAE,iBAAiB,KAAK,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CACtF,CAAC"}

package/lib/host/types/services.js

@@ -0,0 +1,9 @@
+/**
+ * Structural views of the host services this half registers onto but does not
+ * own. The slash-command shapes come from the `commands` service — the headless
+ * mirror surface the card's two executable actions get; the service may be
+ * mounted after `apply` returns (hence the lazy injection) and may not be
+ * mounted at all on a host with no commands plane.
+ */
+export {};
+//# sourceMappingURL=services.js.map

package/lib/host/types/services.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.js","sourceRoot":"","sources":["../../../src/host/types/services.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/lib/host/types/settings.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Types — the configuration form's layers, the live mirror, and the settings
+ * service surface the Host reads and writes through.
+ *
+ * Since dsh 0.2.0 there is one `Config` (./../schema.ts) and one form per profile
+ * row: the card edits the row's volatile fields, and every live answer the Host
+ * has to serve rides the very same references. So there is no separate persisted
+ * section and no base layer to publish over — what the Host reads for the fields
+ * it edits is one read of the row's two layers, and what it serves is one
+ * volatile commit of the mirror.
+ */
+import type { BridgeStderrMode } from "./stderr.js";
+import type { ChromeExecutableEntry, ChromeExecutableStatus, EffectiveChromeSource } from "./executable.js";
+import type { WindowsChromeStatus } from "./windows.js";
+/**
+ * The fields the card edits — the fields the Host persists, and the only ones
+ * whose commits the Host routes (a commit touching nothing here changes nothing
+ * the bridge runs with).
+ */
+export type ConfigUserFields = {
+    extraFlags: string[];
+    /** Written by the card's **Fetch executables** action: one host run that
+     * re-probes the saved rows and folds what it finds back into them. */
+    refreshExecutablesNonce: number;
+    /** Written by the card's **Prelaunch Windows Chrome** button: one host run that
+     * locates the Windows Chrome, proves the mirrored-loopback prereq, launches
+     * it with a debugging port and leaves the bridge in connect mode. Same
+     * trigger idiom as `refreshExecutablesNonce` — an action travels as one write
+     * the Host reacts to, never a push channel. */
+    openWindowsChromeNonce: number;
+    /** The executable the bridge launches with: picked in the picker (a saved
+     * row's path), or seeded once by the host; "" = nothing resolved yet. There
+     * is no "auto" state to fall back to. */
+    chromePath: string;
+    /** The saved-executables rows: `{ id: path, name: label }`, the dropdown's
+     * catalog (see ./catalog.ts). User-authored; a scan merges what it finds
+     * into them without dropping a name the user chose. */
+    executables: ChromeExecutableEntry[];
+    /** The ids of saved rows the user dropped — Host-authored, never edited by
+     * the card, and read by every merge step so a deleted row is never folded
+     * back in (see ../controller/runs.ts). */
+    droppedExecutables: string[];
+    /** **Legacy** MRU of hand-typed executables (oldest drops off past
+     * `CUSTOM_PATHS_CAP`). Nothing writes it any more: the saved rows replace it,
+     * and a host whose profile still carries it folds its paths into the rows on
+     * the first run (see ./catalog.ts). */
+    chromeCustomPaths: string[];
+    /** The card's "Reduce log output" toggle: "log" captures the bridge's
+     * stderr into the log file, "console" echoes it. "" follows the row
+     * config `bridgeStderr`. */
+    stderrMode: "" | BridgeStderrMode;
+};
+/**
+ * The live mirror: what the Host answers through the same volatile references
+ * the card edits, and never persists. Every field here is a volatile field of the
+ * single `Config`, published by one commit per change batch.
+ */
+export type ConfigLiveFields = {
+    /** Last check/connection failure, human-readable; "" when healthy. */
+    lastError: string;
+    /** The last failure was "no Chrome executable detected". */
+    chromeMissing: boolean;
+    /** Completion signal of one executable run (a merged scan, and the probe of
+     * what is selected that follows it). The one counter every executable action
+     * waits on. */
+    executableDiscoveryRevision: number;
+    /** The `--version` line the selected executable answered with; "" when
+     * nothing answered (nothing selected, a connect mode, a blocked path). */
+    chromeVersion: string;
+    /** Per-row probe status, keyed by path. Never persisted — the *rows*
+     * themselves are user-authored. */
+    executableStatus: ChromeExecutableStatus[];
+    /** Executable the bridge actually launches with; "" when nothing is fixed. */
+    effectiveChromePath: string;
+    /** Where `effectiveChromePath` came from. */
+    effectiveSource: EffectiveChromeSource;
+    /** The mode the bridge actually routes console output through — what the
+     * card's toggle is checked against, so it never reads a phantom state. */
+    stderrEffective: BridgeStderrMode;
+    /** The canonical default extra-flags list — what the card's Restore defaults
+     * action appends, keeping whatever the rows already carry. */
+    defaultExtraFlags: string[];
+    /** The recommended WSL ↔ Windows extra-flags list — what the card's **Flags
+     * WSL** action appends, missing entries only. */
+    wslExtraFlags: string[];
+    /** True while this Host runs under WSL **and** the effective executable is a
+     * Windows binary (see ./platform.ts) — the state the card's notice explains. */
+    wslWindowsExecutable: boolean;
+    /** What the **Prelaunch Windows Chrome** run is doing right now. The whole
+     * Windows path lives host-side, so the card renders this one field and
+     * carries no list of Windows paths or reachability rules. */
+    windowsChromeStatus: WindowsChromeStatus;
+    /** True while the bridge launches with a connect-mode flag
+     * (`--browserUrl` / `--wsEndpoint`): there is then no local executable to
+     * launch or probe, so the card mutes the picker instead of claiming a local
+     * selection the bridge is not running. */
+    carriesConnectionMode: boolean;
+    /** The flags the live connection actually launches with (mirrored from the
+     * last resolve) — what the machine page states as running, not what the
+     * layers were last configured with. Empty while nothing resolves. */
+    runningFlags: string[];
+    /** The note the live connection answered with — where its console output
+     * goes, or the debugging URL the Windows run connected to. */
+    runningNote: string;
+};
+/** One layer's answers: a field is absent when that layer said nothing. */
+export type ConfigLayerFields = {
+    [K in keyof ConfigUserFields]?: ConfigUserFields[K];
+};
+/**
+ * One read of the form: what runs now (the references resolve the user layer over
+ * the row config, which is exactly what the bridge launches with) plus the two
+ * layers the distinction "did the user edit this, or does the row config say it"
+ * reads. Before the form is attached the references answer for both layers, so
+ * the first commit settles the distinction.
+ */
+export type ConfigLayers = {
+    value: ConfigUserFields;
+    user: ConfigLayerFields;
+    base: ConfigLayerFields;
+};
+/**
+ * Surface of the `settings` service (`SettingsForms`) as consumed here. Typed
+ * structurally the way `tool.ts` types the tools service: the service lives in
+ * the loader's module table, and the Host only reads a described row, writes a
+ * patch and turns the generated page off. The patch row is keyed by the
+ * **profile entry id**, never by a namespace of the Host's own.
+ */
+/**
+ * One ordered edit a write carries through `mutate`: a `set` names a field with
+ * a value; an `unset` returns the field to whatever the row config answers (an
+ * unset of a path no layer answers drops out of the stored row entirely — this
+ * is exactly how the Host clears its live-only fields back to their row-config
+ * answers; see ./values.ts `liveMirrorKeys`).
+ */
+export type SettingsPathOp = {
+    op: "set";
+    path: readonly string[];
+    value: unknown;
+} | {
+    op: "unset";
+    path: readonly string[];
+};
+export interface SettingsForms {
+    describe(options?: unknown): SettingsFormRow[];
+    /** Write one user-authored field into the row's own patch layer (the store
+     * dsh 0.2.0 uses instead of `settings.yaml`). Never called with a live field. */
+    update(entryId: string, patch: Record<string, unknown>, expectedRevision?: number): Promise<unknown> | unknown;
+    /** One ordered field edit; every edit addresses a volatile field, and an
+     * `unset` falls back to the row-config answer. The Host's write-backs go
+     * through this channel, carrying the live-only fields' clear alongside the
+     * one user field they write, so a live answer can never ride a write back
+     * into the stored layer (see ./values.ts). */
+    mutate(entryId: string, ops: readonly SettingsPathOp[], expectedRevision?: number): Promise<unknown> | unknown;
+    /** `auto: false` keeps the generated page off while the card owns the row's
+     * page. Disposable, and calling it twice for one fiber throws. */
+    configure(presentation: {
+        auto?: boolean;
+    }, owner?: unknown): () => void;
+}
+/** One described settings row (dsh-ancesters `readFormRow`), narrowed to what the Host consults. */
+export interface SettingsFormRow {
+    /** The profile entry id this row is keyed by. */
+    ns: string;
+    /** Live effective value, Host live commits included. */
+    value?: unknown;
+    /** Composition base — what the row config carries under the user layer. */
+    base?: unknown;
+    /** What the profile patch carries (`{}` when it carries nothing). */
+    user?: unknown;
+}
+/** Everything the Host keeps about the form once it attaches. */
+export interface ChromeMcpForm {
+    /** The row's profile entry id — the key every read and write goes through. */
+    entryId: string;
+    /** The form service itself (undefined on the cold path, where only the
+     * references answer). */
+    settings?: SettingsForms;
+}
+//# sourceMappingURL=settings.d.ts.map

package/lib/host/types/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../../src/host/types/settings.ts"],"names":[],"mappings":"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"}

package/lib/host/types/settings.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=settings.js.map

package/lib/host/types/settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.js","sourceRoot":"","sources":["../../../src/host/types/settings.ts"],"names":[],"mappings":""}

package/lib/host/types/stderr.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Types — bridge console-output routing and the per-spawn stderr wrapper.
+ *
+ * These types describe where the spawned bridge's console output goes and the
+ * shapes the wrapper is built from; the runtime lives in ./bridge.ts. Split out
+ * of the single `types.ts` so the stderr plumbing reads as one section.
+ */
+/**
+ * Where the spawned bridge's console output goes. "log" (default) captures the
+ * child's inherited stderr into a per-spawn log file so the dsh console stays
+ * clean while stdout keeps flowing as the MCP protocol stream; "console"
+ * inherits it (debug). Mirrors the reference plugin's gateway stderr modes.
+ */
+export type BridgeStderrMode = "log" | "console";
+/** The spawn-diagnostics subset {@link noteStderr} reads. */
+export type BridgeStderrNotice = {
+    redirect: string;
+};
+/** Spawn target consumed by {@link buildBridgeSpawn}. */
+export type BridgeSpawnTarget = {
+    /** Executable the bridge runs (default `npx`). */
+    command: string;
+    /** Argv tail: `-y <package> [extraFlags]`, plus any appended path pin. */
+    args: string[];
+    /** Effective stderr routing; defaults to "log" when omitted. */
+    stderr?: BridgeStderrMode;
+    /** Explicit log path (""/undefined → the per-spawn default). */
+    logPath?: string;
+    /** Bridge server namespace (sanitized into the default log name). */
+    serverName?: string;
+};
+/** Options for {@link buildBridgeSpawn}. */
+export type BridgeSpawnOptions = {
+    /** The Node that runs the wrapper; defaults to `process.execPath`. */
+    execPath?: string;
+    tmpdir?: string;
+    pid?: number;
+};
+/** One built bridge spawn: the (possibly wrapped) command/args plus where the
+ * stderr lands (`redirect`, "" when echoed). */
+export type BridgeSpawnResult = {
+    command: string;
+    args: string[];
+    redirect: string;
+};
+/** Options for {@link bridgeStderrLogPath}. */
+export type BridgeStderrLogPathOptions = {
+    tmpdir?: string;
+    pid?: number;
+};
+//# sourceMappingURL=stderr.d.ts.map

package/lib/host/types/stderr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stderr.d.ts","sourceRoot":"","sources":["../../../src/host/types/stderr.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,SAAS,CAAC;AAEjD,6DAA6D;AAC7D,MAAM,MAAM,kBAAkB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtD,yDAAyD;AACzD,MAAM,MAAM,iBAAiB,GAAG;IAC5B,kDAAkD;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB,0EAA0E;IAC1E,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,gEAAgE;IAChE,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,4CAA4C;AAC5C,MAAM,MAAM,kBAAkB,GAAG;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;gDACgD;AAChD,MAAM,MAAM,iBAAiB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtF,+CAA+C;AAC/C,MAAM,MAAM,0BAA0B,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/lib/host/types/stderr.js

@@ -0,0 +1,9 @@
+/**
+ * Types — bridge console-output routing and the per-spawn stderr wrapper.
+ *
+ * These types describe where the spawned bridge's console output goes and the
+ * shapes the wrapper is built from; the runtime lives in ./bridge.ts. Split out
+ * of the single `types.ts` so the stderr plumbing reads as one section.
+ */
+export {};
+//# sourceMappingURL=stderr.js.map

package/lib/host/types/stderr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stderr.js","sourceRoot":"","sources":["../../../src/host/types/stderr.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/lib/host/types/windows.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Types — the **Prelaunch Windows Chrome** run's state machine and outcome.
+ *
+ * Everything the card derives the Windows button's state from: the single
+ * `windowsChromeStatus` base-layer field plus the run's own richer answer. Split
+ * out of the single `types.ts`; the run itself lives in ../windows/.
+ */
+/**
+ * What the **Prelaunch Windows Chrome** run is currently doing — the single field
+ * the card derives the button's enabled state, its disabled reason and the
+ * pill's connect-mode muting from. Base-layer mirror (host state, never
+ * persisted).
+ *
+ * `not-applicable` is the non-WSL answer (nothing to drive off this host);
+ * `not-found`, `unreachable` and `launch-failed` are the run's failure states;
+ * `launching` covers both the launch and the wait for the port to bind.
+ */
+export type WindowsChromeState = "off" | "launching" | "connected" | "unreachable" | "not-found" | "launch-failed" | "not-applicable";
+/** The served Windows-Chrome status: the state machine, the debugging port it
+ * settled on (0 = none), and the failure line when the last answer failed. */
+export type WindowsChromeStatus = {
+    state: WindowsChromeState;
+    port: number;
+    error: string;
+};
+/** One workspace-view link answer: created, moved, left alone (a real
+ * directory is already there), or unusable. */
+export type WindowsChromeLinkAnswer = "linked" | "updated" | "kept" | "failed";
+/** The outcome of one {@link runWindowsChromeConnect}: the same shape the base
+ * layer carries, plus the connect address the bridge has to run with for the
+ * state to be true ("" when there is nothing to connect to), and the
+ * Windows-side profile directory a successful run settled on ("" when the run
+ * never got that far) with the workspace-view link it refreshed. */
+export type WindowsChromeRun = WindowsChromeStatus & {
+    url: string;
+    profileDir: string;
+    profileLink?: WindowsChromeLinkAnswer;
+};
+//# sourceMappingURL=windows.d.ts.map

package/lib/host/types/windows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"windows.d.ts","sourceRoot":"","sources":["../../../src/host/types/windows.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;GASG;AACH,MAAM,MAAM,kBAAkB,GACxB,KAAK,GACL,WAAW,GACX,WAAW,GACX,aAAa,GACb,WAAW,GACX,eAAe,GACf,gBAAgB,CAAC;AAEvB;8EAC8E;AAC9E,MAAM,MAAM,mBAAmB,GAAG;IAAE,KAAK,EAAE,kBAAkB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7F;+CAC+C;AAC/C,MAAM,MAAM,uBAAuB,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE/E;;;;oEAIoE;AACpE,MAAM,MAAM,gBAAgB,GAAG,mBAAmB,GAAG;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,uBAAuB,CAAC;CACzC,CAAC"}

package/lib/host/types/windows.js

@@ -0,0 +1,9 @@
+/**
+ * Types — the **Prelaunch Windows Chrome** run's state machine and outcome.
+ *
+ * Everything the card derives the Windows button's state from: the single
+ * `windowsChromeStatus` base-layer field plus the run's own richer answer. Split
+ * out of the single `types.ts`; the run itself lives in ../windows/.
+ */
+export {};
+//# sourceMappingURL=windows.js.map

package/lib/host/types/windows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"windows.js","sourceRoot":"","sources":["../../../src/host/types/windows.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}