@comecaramelos/dsh-chrome-mcp 0.0.1 → 2.0.0

package/lib/host/platform.js

@@ -0,0 +1,64 @@
+/**
+ * Host half — where the plugin is running: is this Linux host a Windows
+ * Subsystem for Linux instance, and does one executable path name a Windows
+ * binary rather than a Linux one.
+ *
+ * The two answers only ever combine into one warning. Launching a Windows
+ * `chrome.exe` from WSL cannot work (`.probe/`, AGENTS.md): the debug pipes
+ * `chrome-devtools-mcp` opens do not survive the interop boundary, and the
+ * debugging port it reads from `DevToolsActivePort` stays bound to the Windows
+ * loopback, unreachable across the WSL2 NAT bridge. It even *seems* to work: the
+ * `--version` probe answers successfully, so a broken selection hides behind a
+ * healthy pill until the first tool call. That is why the pair is surfaced on
+ * the card as its own notice rather than through the error dot: nothing is
+ * failing yet, the required configuration is simply different.
+ *
+ * Both probes stay pure and injectable (`platform`, `env`, `exists`) so the
+ * tests never depend on the machine they run on.
+ */
+import { existsSync } from "node:fs";
+import { WINDOWS_EXE_PATTERN, WINDOWS_PATH_PATTERN, WSL_ENV_VARS, WSL_INTEROP_MARKER } from "./constants.js";
+/**
+ * True when `path` names a Windows binary — one that lives on the interop mount
+ * (`/mnt/<drive>/…`), in a Windows spelling (`\\host\…`, `C:\…`), or simply
+ * carries the PE suffix. A Linux path is never Windows-side, and a candidate
+ * list built from {@link DEFAULT_CHROME_PATHS} never matches.
+ * @param path - one executable path as selected.
+ */
+export function isWindowsExecutablePath(path) {
+    if (typeof path !== "string")
+        return false;
+    const candidate = path.trim();
+    if (candidate === "")
+        return false;
+    return WINDOWS_PATH_PATTERN.test(candidate) || WINDOWS_EXE_PATTERN.test(candidate);
+}
+/**
+ * True when the current process runs inside Windows Subsystem for Linux: a
+ * Linux kernel plus the WSL markers. A non-Linux platform (a plain Windows
+ * host) is never "under WSL", whatever its environment says.
+ * @param probe - what to consult (defaults to this process).
+ */
+export function isWindowsSubsystemForLinux(probe = {}) {
+    const platform = probe.platform ?? process.platform;
+    if (platform !== "linux")
+        return false;
+    if (probe.env !== void 0) {
+        return WSL_ENV_VARS.some((name) => {
+            const value = probe.env(name);
+            return typeof value === "string" && value.trim() !== "";
+        });
+    }
+    return (probe.exists ?? ((candidate) => existsSync(candidate)))(WSL_INTEROP_MARKER);
+}
+/**
+ * The interop trap the card warns about: we are under WSL **and** what is
+ * selected is a Windows executable. Both halves are required — a Linux binary
+ * selected on a Windows host is simply nothing to say.
+ * @param path - the effective executable path.
+ * @param probe - what to consult for the environment (defaults to this process).
+ */
+export function isWindowsExecutableUnderWsl(path, probe = {}) {
+    return isWindowsSubsystemForLinux(probe) && isWindowsExecutablePath(path);
+}
+//# sourceMappingURL=platform.js.map

package/lib/host/platform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.js","sourceRoot":"","sources":["../../src/host/platform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAiB7G;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAAa;IACjD,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC3C,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IAC9B,IAAI,SAAS,KAAK,EAAE;QAAE,OAAO,KAAK,CAAC;IACnC,OAAO,oBAAoB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,mBAAmB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AACvF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,0BAA0B,CAAC,QAAuB,EAAE;IAChE,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC;IACpD,IAAI,QAAQ,KAAK,OAAO;QAAE,OAAO,KAAK,CAAC;IACvC,IAAI,KAAK,CAAC,GAAG,KAAK,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;YAC9B,MAAM,KAAK,GAAG,KAAK,CAAC,GAAI,CAAC,IAAI,CAAC,CAAC;YAC/B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC;QAC5D,CAAC,CAAC,CAAC;IACP,CAAC;IACD,OAAO,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,SAAiB,EAAE,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC;AAChG,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CAAC,IAAa,EAAE,QAAuB,EAAE;IAChF,OAAO,0BAA0B,CAAC,KAAK,CAAC,IAAI,uBAAuB,CAAC,IAAI,CAAC,CAAC;AAC9E,CAAC"}

package/lib/host/plugin-meta.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Host-half plugin identity.
+ *
+ * `name` is what the cordis loader reports for diagnostics and `inject` is the
+ * list of host services this half needs of its own; the connection fibers
+ * declare the tools, so the only service this row itself asks for is the
+ * manager's.
+ */
+/** Cordis plugin name used by loader diagnostics. */
+export declare const name = "chrome-devtools-mcp";
+/**
+ * The host services this component needs of its own.
+ *
+ * `mcpConnections` is what the MCP manager *provides*: it is how this component
+ * says "there are two kinds of connection here — `chrome` and `chrome-windows`
+ * — and here is what one runs with". Declaring it is what the component being a
+ * component means — without the manager the injection never answers, so the row
+ * describes itself, answers its pickers, and starts nothing.
+ */
+export declare const inject: string[];
+//# sourceMappingURL=plugin-meta.d.ts.map

package/lib/host/plugin-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-meta.d.ts","sourceRoot":"","sources":["../../src/host/plugin-meta.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,qDAAqD;AACrD,eAAO,MAAM,IAAI,wBAAwB,CAAC;AAE1C;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,EAAuB,CAAC"}

package/lib/host/plugin-meta.js

@@ -0,0 +1,21 @@
+/**
+ * Host-half plugin identity.
+ *
+ * `name` is what the cordis loader reports for diagnostics and `inject` is the
+ * list of host services this half needs of its own; the connection fibers
+ * declare the tools, so the only service this row itself asks for is the
+ * manager's.
+ */
+/** Cordis plugin name used by loader diagnostics. */
+export const name = "chrome-devtools-mcp";
+/**
+ * The host services this component needs of its own.
+ *
+ * `mcpConnections` is what the MCP manager *provides*: it is how this component
+ * says "there are two kinds of connection here — `chrome` and `chrome-windows`
+ * — and here is what one runs with". Declaring it is what the component being a
+ * component means — without the manager the injection never answers, so the row
+ * describes itself, answers its pickers, and starts nothing.
+ */
+export const inject = ["mcpConnections"];
+//# sourceMappingURL=plugin-meta.js.map

package/lib/host/plugin-meta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-meta.js","sourceRoot":"","sources":["../../src/host/plugin-meta.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,qDAAqD;AACrD,MAAM,CAAC,MAAM,IAAI,GAAG,qBAAqB,CAAC;AAE1C;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,MAAM,GAAa,CAAC,gBAAgB,CAAC,CAAC"}

package/lib/host/schema.d.ts

@@ -0,0 +1,361 @@
+/**
+ * The single zod `Config` of the plugin row.
+ *
+ * Since dsh 0.2.0 the Web GUI card edits the **row configuration** through the
+ * profile's configuration form — there is no separate `settings.yaml` namespace
+ * and no base layer to publish state over. So one schema carries everything the
+ * card reads and writes, and every field the card touches is declared
+ * `.volatile()`: a volatile field is editable through the form without
+ * remounting the plugin, its user layer rides the profile patch instead of
+ * `settings.yaml`, and a live value the Host commits never reaches the patch
+ * (the form write strips the volatile fields out of the stored layer before
+ * merging).
+ *
+ * Ordinary fields (`serverName`, `command`, `package`, `chromePaths`, `env`,
+ * `cwd`, `toolCallTimeoutMs`, `maxInstructionBytes`, `failOnStartupError`,
+ * `reconnect`, `bridgeStderrLog`) are composition-only: the card reads them, it
+ * never edits them, and a form write naming one of them is refused by
+ * dsh-settings.
+ *
+ * Host-resolved fields carry the live value in the reference, so the Host
+ * publishes them through the live mirror (dsh-ancesters `createLiveMirror`) — never with the form.
+ */
+import z from "@deepseek-ai/schemastery";
+/**
+ * The plugin row's configuration, and the configuration form the Web GUI card
+ * edits. Every `.volatile()` field below is live: a user edit lands in the
+ * profile patch and commits without a remount, and the Host's own live answers
+ * ride the same references without ever being persisted.
+ */
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    serverName: z<string, string, "defined">;
+    command: z<string, string, "defined">;
+    package: z<string, string, "defined">;
+    /** Flags appended after `npx -y <package>`; the card's last UI edit. The
+     * field's own pattern is what refuses them (an entry that carries a control
+     * character never resolves, so a write is refused Host-side rather than
+     * landing in argv); an executable-pinning flag is rejected by the Host fold
+     * because the executable is picked below. */
+    extraFlags: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    chromePaths: z<string[], string[], "defined">;
+    env: z<import("@deepseek-ai/cosmokit").Dict<string, string>, import("@deepseek-ai/cosmokit").Dict<string, string>, "defined">;
+    cwd: z<string, string, "defined">;
+    toolCallTimeoutMs: z<number, number, "defined">;
+    /** Ceiling for the bridge's server instructions (UTF-8 bytes, attribution
+     * included); an oversized description rejects the connection. Mirrors
+     * `dsh-mcp-client`'s own field and default (32768) — a passthrough for a
+     * server whose instructions run longer than the cap. */
+    maxInstructionBytes: z<number, number, "defined">;
+    failOnStartupError: z<boolean, boolean, "defined">;
+    reconnect: z<Schemastery.ObjectS<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        initialDelayMs: z<number, number, "defined">;
+        maxDelayMs: z<number, number, "defined">;
+        maxAttempts: z<number, number, "defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        initialDelayMs: z<number, number, "defined">;
+        maxDelayMs: z<number, number, "defined">;
+        maxAttempts: z<number, number, "defined">;
+    }>>, "plain">;
+    /** Bridge console-output routing: "log" (default) redirects the spawned
+     * npx child's inherited stderr into a per-spawn log file so its progress
+     * / startup lines stay out of the dsh console; "console" inherits it
+     * (debug). The card's "Reduce log output" toggle (`stderrMode`) overrides
+     * this. See {@link buildBridgeSpawn}. */
+    bridgeStderr: z<"log" | "console", "log" | "console", "defined">;
+    /** Log path override for "log" mode; "" = auto (see
+     * {@link bridgeStderrLogPath}). Absolute paths only. */
+    bridgeStderrLog: z<string, string, "defined">;
+    /**
+     * The executable the bridge launches with: picked in the picker (a saved
+     * row's `id`) or seeded once by the Host's first scan. "" = nothing
+     * resolved yet — there is no auto state to fall back to.
+     */
+    chromePath: z<string, string, "volatile-defined">;
+    /** The picker's saved rows — `{ id: path, name: label }`, user-authored. The
+     * Host re-normalizes (trim, dedupe, caps) on every read, and a scan merges
+     * what it discovers into them without dropping a name the user chose. */
+    executables: z<NoInfer<({
+        id?: string | null | undefined;
+        name?: string | null | undefined;
+    } & import("@deepseek-ai/cosmokit").Dict)[]>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        id: z<string, string, "defined">;
+        name: z<string, string, "defined">;
+    }>>[]>, "volatile-defined">;
+    /** The ids of saved rows the user dropped. Every run folds what it found
+     * back into the rows, and the found list keeps answering a path the user
+     * just deleted, so without this record a dropped row stood back up on the
+     * very run the deletion queued (measured live 2026-10-12: the (x86)
+     * Windows-executable row read as a delete that never landed). Merge steps
+     * skip every id standing here; a list write carrying the id again clears
+     * it. Host-authored: the card never edits this field. */
+    droppedExecutables: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    /**
+     * **Legacy** MRU of hand-typed executables, newest first. The saved rows
+     * replace it: a Host whose profile still carries it folds its paths into
+     * the rows during the first scan (see ./catalog.ts `mergeEntries`), so the
+     * field is read once and never written again.
+     */
+    chromeCustomPaths: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    /**
+     * The card's "Reduce log output" toggle: "log" captures the bridge's
+     * stderr into the log file, "console" echoes it (debug). "" follows the
+     * row-config `bridgeStderr`.
+     */
+    stderrMode: z<string, string, "volatile-defined">;
+    /** The mode the bridge actually routes console output through — the UI
+     * toggle when it states one, else the row config. Mirrored live so the
+     * toggle never reads a phantom state (see `resolveStderrMode`). */
+    stderrEffective: z<"log" | "console", "log" | "console", "volatile-defined">;
+    /** Written by the card's **Fetch executables** button; the Host reacts by
+     * re-probing the saved rows and merging what it finds back into them. */
+    refreshExecutablesNonce: z<number, number, "volatile-defined">;
+    /** Written by the card's **Prelaunch Windows Chrome** button; the Host
+     * reacts by running the Windows launch: locate the Windows Chrome, prove
+     * the mirrored-loopback prereq, launch it with a debugging port, and write
+     * the `--browserUrl` connect entry that leaves the bridge in connect mode. */
+    openWindowsChromeNonce: z<number, number, "volatile-defined">;
+    /**
+     * Whether the translation of this row's **standalone** configuration was
+     * offered and turned down. Host-authored:
+     * the card never edits it — only the proposal's dismiss action does.
+     */
+    migrationDismissed: z<boolean, boolean, "volatile-defined">;
+    /** Last check/connection failure, human-readable; empty when healthy. */
+    lastError: z<string, string, "volatile-defined">;
+    /** Known error: the last failure was "no Chrome executable detected". */
+    chromeMissing: z<boolean, boolean, "volatile-defined">;
+    /** Executable-run counter (success or failure); completion signal for every
+     * executable action the card can take. */
+    executableDiscoveryRevision: z<number, number, "volatile-defined">;
+    /** The version the **selected** executable answered with; "" when nothing
+     * answered — nothing picked, a connect mode, or a blocked path. */
+    chromeVersion: z<string, string, "volatile-defined">;
+    /** Per-row probe status keyed by path: the version the row answered with,
+     * and the failure for a row that is present but not runnable (or blocked). */
+    executableStatus: z<NoInfer<({
+        path?: string | null | undefined;
+        version?: string | null | undefined;
+        error?: string | null | undefined;
+        note?: string | null | undefined;
+    } & import("@deepseek-ai/cosmokit").Dict)[]>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        path: z<string, string, "defined">;
+        version: z<string, string, "defined">;
+        error: z<string, string, "defined">;
+        note: z<string, string, "defined">;
+    }>>[]>, "volatile-defined">;
+    /** The path the bridge actually launches with ("" when nothing is fixed). */
+    effectiveChromePath: z<string, string, "volatile-defined">;
+    /** Where `effectiveChromePath` came from — picked (`"selected"`), row config
+     * (`"row-config"`) or nothing yet (""). */
+    effectiveSource: z<string, string, "volatile-defined">;
+    /** The canonical default extra-flags list — the list the card's **Restore
+     * defaults** control appends to what the editor holds. Mirror of
+     * `DEFAULT_EXTRA_FLAGS`, served so the card carries no copy of it. */
+    defaultExtraFlags: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    /** The recommended WSL ↔ Windows extra-flags list — the list the card's
+     * **Flags WSL** control appends, missing entries only. Mirror of
+     * `WSL_EXTRA_FLAGS`, served so the card carries no copy of it. */
+    wslExtraFlags: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    /** True while this Host runs under WSL and the selected executable is a
+     * Windows binary — the state the card's notice explains (see ./platform.ts). */
+    wslWindowsExecutable: z<boolean, boolean, "volatile-defined">;
+    /** What the **Prelaunch Windows Chrome** run is doing — the single field
+     * the card derives the button's state, its disabled reason and the pill's
+     * connect-mode muting from. Every half (locate, prereq, launch, port) lives
+     * Host-side (./windows/), so the card carries no list of Windows paths or
+     * reachability rules. */
+    windowsChromeStatus: z<NoInfer<Schemastery.ObjectS<NoInfer<{
+        state: z<string, string, "defined">;
+        port: z<number, number, "defined">;
+        error: z<string, string, "defined">;
+    }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        state: z<string, string, "defined">;
+        port: z<number, number, "defined">;
+        error: z<string, string, "defined">;
+    }>>>, "volatile-defined">;
+    /** True while the bridge launches with a connect-mode flag (`--browserUrl`
+     * / `--wsEndpoint`): no local executable is then launched or probed, so the
+     * card mutes the picker. */
+    carriesConnectionMode: z<boolean, boolean, "volatile-defined">;
+    /** The flags a live connection of this component's own kinds actually
+     * launches with — mirrored from the last `resolve`, not from any layer, so
+     * the machine page states what is running rather than what was last
+     * configured. Empty while nothing resolves. */
+    runningFlags: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    /** The note the last live connection answered with — where its console
+     * output goes, or the Windows URL it connected to. "" when the answer was
+     * silent. */
+    runningNote: z<string, string, "volatile-defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    serverName: z<string, string, "defined">;
+    command: z<string, string, "defined">;
+    package: z<string, string, "defined">;
+    /** Flags appended after `npx -y <package>`; the card's last UI edit. The
+     * field's own pattern is what refuses them (an entry that carries a control
+     * character never resolves, so a write is refused Host-side rather than
+     * landing in argv); an executable-pinning flag is rejected by the Host fold
+     * because the executable is picked below. */
+    extraFlags: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    chromePaths: z<string[], string[], "defined">;
+    env: z<import("@deepseek-ai/cosmokit").Dict<string, string>, import("@deepseek-ai/cosmokit").Dict<string, string>, "defined">;
+    cwd: z<string, string, "defined">;
+    toolCallTimeoutMs: z<number, number, "defined">;
+    /** Ceiling for the bridge's server instructions (UTF-8 bytes, attribution
+     * included); an oversized description rejects the connection. Mirrors
+     * `dsh-mcp-client`'s own field and default (32768) — a passthrough for a
+     * server whose instructions run longer than the cap. */
+    maxInstructionBytes: z<number, number, "defined">;
+    failOnStartupError: z<boolean, boolean, "defined">;
+    reconnect: z<Schemastery.ObjectS<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        initialDelayMs: z<number, number, "defined">;
+        maxDelayMs: z<number, number, "defined">;
+        maxAttempts: z<number, number, "defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        initialDelayMs: z<number, number, "defined">;
+        maxDelayMs: z<number, number, "defined">;
+        maxAttempts: z<number, number, "defined">;
+    }>>, "plain">;
+    /** Bridge console-output routing: "log" (default) redirects the spawned
+     * npx child's inherited stderr into a per-spawn log file so its progress
+     * / startup lines stay out of the dsh console; "console" inherits it
+     * (debug). The card's "Reduce log output" toggle (`stderrMode`) overrides
+     * this. See {@link buildBridgeSpawn}. */
+    bridgeStderr: z<"log" | "console", "log" | "console", "defined">;
+    /** Log path override for "log" mode; "" = auto (see
+     * {@link bridgeStderrLogPath}). Absolute paths only. */
+    bridgeStderrLog: z<string, string, "defined">;
+    /**
+     * The executable the bridge launches with: picked in the picker (a saved
+     * row's `id`) or seeded once by the Host's first scan. "" = nothing
+     * resolved yet — there is no auto state to fall back to.
+     */
+    chromePath: z<string, string, "volatile-defined">;
+    /** The picker's saved rows — `{ id: path, name: label }`, user-authored. The
+     * Host re-normalizes (trim, dedupe, caps) on every read, and a scan merges
+     * what it discovers into them without dropping a name the user chose. */
+    executables: z<NoInfer<({
+        id?: string | null | undefined;
+        name?: string | null | undefined;
+    } & import("@deepseek-ai/cosmokit").Dict)[]>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        id: z<string, string, "defined">;
+        name: z<string, string, "defined">;
+    }>>[]>, "volatile-defined">;
+    /** The ids of saved rows the user dropped. Every run folds what it found
+     * back into the rows, and the found list keeps answering a path the user
+     * just deleted, so without this record a dropped row stood back up on the
+     * very run the deletion queued (measured live 2026-10-12: the (x86)
+     * Windows-executable row read as a delete that never landed). Merge steps
+     * skip every id standing here; a list write carrying the id again clears
+     * it. Host-authored: the card never edits this field. */
+    droppedExecutables: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    /**
+     * **Legacy** MRU of hand-typed executables, newest first. The saved rows
+     * replace it: a Host whose profile still carries it folds its paths into
+     * the rows during the first scan (see ./catalog.ts `mergeEntries`), so the
+     * field is read once and never written again.
+     */
+    chromeCustomPaths: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    /**
+     * The card's "Reduce log output" toggle: "log" captures the bridge's
+     * stderr into the log file, "console" echoes it (debug). "" follows the
+     * row-config `bridgeStderr`.
+     */
+    stderrMode: z<string, string, "volatile-defined">;
+    /** The mode the bridge actually routes console output through — the UI
+     * toggle when it states one, else the row config. Mirrored live so the
+     * toggle never reads a phantom state (see `resolveStderrMode`). */
+    stderrEffective: z<"log" | "console", "log" | "console", "volatile-defined">;
+    /** Written by the card's **Fetch executables** button; the Host reacts by
+     * re-probing the saved rows and merging what it finds back into them. */
+    refreshExecutablesNonce: z<number, number, "volatile-defined">;
+    /** Written by the card's **Prelaunch Windows Chrome** button; the Host
+     * reacts by running the Windows launch: locate the Windows Chrome, prove
+     * the mirrored-loopback prereq, launch it with a debugging port, and write
+     * the `--browserUrl` connect entry that leaves the bridge in connect mode. */
+    openWindowsChromeNonce: z<number, number, "volatile-defined">;
+    /**
+     * Whether the translation of this row's **standalone** configuration was
+     * offered and turned down. Host-authored:
+     * the card never edits it — only the proposal's dismiss action does.
+     */
+    migrationDismissed: z<boolean, boolean, "volatile-defined">;
+    /** Last check/connection failure, human-readable; empty when healthy. */
+    lastError: z<string, string, "volatile-defined">;
+    /** Known error: the last failure was "no Chrome executable detected". */
+    chromeMissing: z<boolean, boolean, "volatile-defined">;
+    /** Executable-run counter (success or failure); completion signal for every
+     * executable action the card can take. */
+    executableDiscoveryRevision: z<number, number, "volatile-defined">;
+    /** The version the **selected** executable answered with; "" when nothing
+     * answered — nothing picked, a connect mode, or a blocked path. */
+    chromeVersion: z<string, string, "volatile-defined">;
+    /** Per-row probe status keyed by path: the version the row answered with,
+     * and the failure for a row that is present but not runnable (or blocked). */
+    executableStatus: z<NoInfer<({
+        path?: string | null | undefined;
+        version?: string | null | undefined;
+        error?: string | null | undefined;
+        note?: string | null | undefined;
+    } & import("@deepseek-ai/cosmokit").Dict)[]>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        path: z<string, string, "defined">;
+        version: z<string, string, "defined">;
+        error: z<string, string, "defined">;
+        note: z<string, string, "defined">;
+    }>>[]>, "volatile-defined">;
+    /** The path the bridge actually launches with ("" when nothing is fixed). */
+    effectiveChromePath: z<string, string, "volatile-defined">;
+    /** Where `effectiveChromePath` came from — picked (`"selected"`), row config
+     * (`"row-config"`) or nothing yet (""). */
+    effectiveSource: z<string, string, "volatile-defined">;
+    /** The canonical default extra-flags list — the list the card's **Restore
+     * defaults** control appends to what the editor holds. Mirror of
+     * `DEFAULT_EXTRA_FLAGS`, served so the card carries no copy of it. */
+    defaultExtraFlags: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    /** The recommended WSL ↔ Windows extra-flags list — the list the card's
+     * **Flags WSL** control appends, missing entries only. Mirror of
+     * `WSL_EXTRA_FLAGS`, served so the card carries no copy of it. */
+    wslExtraFlags: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    /** True while this Host runs under WSL and the selected executable is a
+     * Windows binary — the state the card's notice explains (see ./platform.ts). */
+    wslWindowsExecutable: z<boolean, boolean, "volatile-defined">;
+    /** What the **Prelaunch Windows Chrome** run is doing — the single field
+     * the card derives the button's state, its disabled reason and the pill's
+     * connect-mode muting from. Every half (locate, prereq, launch, port) lives
+     * Host-side (./windows/), so the card carries no list of Windows paths or
+     * reachability rules. */
+    windowsChromeStatus: z<NoInfer<Schemastery.ObjectS<NoInfer<{
+        state: z<string, string, "defined">;
+        port: z<number, number, "defined">;
+        error: z<string, string, "defined">;
+    }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        state: z<string, string, "defined">;
+        port: z<number, number, "defined">;
+        error: z<string, string, "defined">;
+    }>>>, "volatile-defined">;
+    /** True while the bridge launches with a connect-mode flag (`--browserUrl`
+     * / `--wsEndpoint`): no local executable is then launched or probed, so the
+     * card mutes the picker. */
+    carriesConnectionMode: z<boolean, boolean, "volatile-defined">;
+    /** The flags a live connection of this component's own kinds actually
+     * launches with — mirrored from the last `resolve`, not from any layer, so
+     * the machine page states what is running rather than what was last
+     * configured. Empty while nothing resolves. */
+    runningFlags: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    /** The note the last live connection answered with — where its console
+     * output goes, or the Windows URL it connected to. "" when the answer was
+     * silent. */
+    runningNote: z<string, string, "volatile-defined">;
+}>>, "plain">;
+/** What one row's configuration **form** answers with — every field resolved to a
+ * plain, nullable value (`TypeS`, not `TypeT`: the volatile fields stay plain here,
+ * they are not wrapped references). This is the stored/described shape: what a
+ * described settings row carries, and what the card reads out of its snapshot.
+ * What `apply` receives is **not** this shape — every `.volatile()` field of it
+ * arrives as a reference instead, which is why the host half carries its own
+ * runtime view in ./types/config.ts (`ChromeMcpConfig`). */
+export type ConfigFormValues = Schemastery.TypeS<typeof Config>;
+//# sourceMappingURL=schema.d.ts.map

package/lib/host/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/host/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,CAAC,MAAM,0BAA0B,CAAC;AAoDzC;;;;;GAKG;AACH,eAAO,MAAM,MAAM;;;;IAIf;;;;iDAI6C;;;;;;IAM7C;;;4DAGwD;;;;;;;;;;;;;;IAIxD;;;;6CAIyC;;IAEzC;4DACwD;;IAKxD;;;;OAIG;;IAEH;;6EAEyE;;;;;;;;IAEzE;;;;;;6DAMyD;;IAEzD;;;;;OAKG;;IAEH;;;;OAIG;;IAEH;;uEAEmE;;IAEnE;6EACyE;;IAEzE;;;kFAG8E;;IAE9E;;;;OAIG;;IAKH,yEAAyE;;IAEzE,yEAAyE;;IAEzE;8CAC0C;;IAE1C;uEACmE;;IAEnE;kFAC8E;;;;;;;;;;;;IAE9E,6EAA6E;;IAE7E;+CAC2C;;IAE3C;;0EAEsE;;IAEtE;;sEAEkE;;IAElE;oFACgF;;IAEhF;;;;6BAIyB;;;;;;;;;;IAEzB;;gCAE4B;;IAE5B;;;mDAG+C;;IAE/C;;iBAEa;;;;;;IA/Hb;;;;iDAI6C;;;;;;IAM7C;;;4DAGwD;;;;;;;;;;;;;;IAIxD;;;;6CAIyC;;IAEzC;4DACwD;;IAKxD;;;;OAIG;;IAEH;;6EAEyE;;;;;;;;IAEzE;;;;;;6DAMyD;;IAEzD;;;;;OAKG;;IAEH;;;;OAIG;;IAEH;;uEAEmE;;IAEnE;6EACyE;;IAEzE;;;kFAG8E;;IAE9E;;;;OAIG;;IAKH,yEAAyE;;IAEzE,yEAAyE;;IAEzE;8CAC0C;;IAE1C;uEACmE;;IAEnE;kFAC8E;;;;;;;;;;;;IAE9E,6EAA6E;;IAE7E;+CAC2C;;IAE3C;;0EAEsE;;IAEtE;;sEAEkE;;IAElE;oFACgF;;IAEhF;;;;6BAIyB;;;;;;;;;;IAEzB;;gCAE4B;;IAE5B;;;mDAG+C;;IAE/C;;iBAEa;;aAEf,CAAC;AAEH;;;;;;4DAM4D;AAC5D,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC"}