@comecaramelos/dsh-chrome-mcp 0.0.1 → 2.0.0

package/lib/host/constants.js

@@ -0,0 +1,319 @@
+/**
+ * Host-half fixed identifiers, budgets and validation patterns.
+ *
+ * The strings are a public contract — the profile entry id is both the
+ * persistence key and the Web card's configuration-form key — and the budgets
+ * are what the README and the tests quote, so they live here once and every
+ * module imports rather than repeats them.
+ */
+/**
+ * The profile entry id the bundle patch inserts (`cordis.patch.yml`), and the
+ * key every read and write of the configuration form goes through. Since dsh
+ * 0.2.0 the card addresses the Host through the **entry id**, not a namespace of
+ * its own, and `serverName` is not part of that identity. The Host reads the
+ * live id off its own fiber (`chromeMcpEntryId`) so a renamed row keeps
+ * working; this constant is what the loud failure and the log lines name.
+ */
+export const ENTRY_ID = "mcp-chrome";
+/** Environment variable that seeds the launch flags for one dsh run. */
+export const FLAGS_ENV_VAR = "DSH_CHROME_MCP_FLAGS";
+/**
+ * Flag entries are appended verbatim to the bridge argv and reach Chrome via
+ * a direct execve (no shell), so shell metacharacters cannot execute here.
+ * What must never reach argv is control characters (newlines, NULs) — they
+ * corrupt the argument framing, so entries may not contain any. This is the
+ * `extraFlags` field's own pattern: a form write naming a control character is
+ * refused Host-side, by the schema rather than by a `validate` hook.
+ */
+export const CONTROL_PATTERN = /[\x00-\x1f\x7f]/u;
+/**
+ * One `extraFlags` entry as a form write may land it: non-empty, and no control
+ * character. This is the field's own pattern, so the gate that refuses them is
+ * the **schema**, not a `validate` hook — the write path runs it Host-side, on
+ * every layer (a row config carrying a newline fails to resolve rather than
+ * reaching argv as a corrupt entry). Spaces inside a value stay allowed: a
+ * Windows-style path in a flag value is one argv item, never a shell word (see
+ * ./flags.ts `validateExtraFlags` for what the paths the form never edits —
+ * `DSH_CHROME_MCP_FLAGS`, the row config — still check).
+ */
+export const EXTRA_FLAG_PATTERN = /^(?:[^\x00-\x1f\x7f]+)$/u;
+/** Flags every launch carries unless the user overrides them. */
+export const DEFAULT_EXTRA_FLAGS = ["--no-usage-statistics", "--no-performance-crux"];
+/**
+ * The flags the card's **Flags WSL** control appends for a WSL ↔ Windows
+ * debugging setup — a fixed recommendation, not a setting and never persisted.
+ * The shape is what makes it actually reach the browser:
+ *
+ * - the debug port travels as `--chromeArg=--remote-debugging-port=9222`:
+ *   the bridge's strict parser knows only its own option names, so a bare
+ *   `--remote-debugging-port` is reported as `Unknown arguments` and dropped
+ *   before any browser is launched; as a `chromeArg` it lands in Chrome's own
+ *   argv and the debugging port opens (see the "Browser switches" hard
+ *   constraint).
+ *
+ * A `--user-data-dir` entry is deliberately **not** recommended alongside it.
+ * The idea of carrying the profile as a project-rooted `.chrome` was measured
+ * to be impossible for the Windows executable: a Windows `chrome.exe` profile
+ * directory has to live on a Windows-local path — neither the WSL checkout
+ * nor the `\\wsl.localhost` mount can carry its locks (9P) — so the
+ * **Prelaunch Windows Chrome** run launches with its own Windows-native
+ * profile under `%LOCALAPPDATA%`, and the one entry this list recommends is
+ * the debug port the run answers on.
+ */
+export const WSL_EXTRA_FLAGS = ["--chromeArg=--remote-debugging-port=9222"];
+/** Upstream configuration docs surfaced by the client card link. */
+export const CONFIGURATION_DOCS_URL = "https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/docs/configuration.md";
+/** Timeout for one check subprocess (chrome executable probe). */
+export const CHECK_TIMEOUT_MS = 15000;
+/**
+ * What a Windows executable answers when no version folder sits beside it. On
+ * Windows a Chromium browser does not answer `--version`: it opens a window
+ * (or hands one to the instance already running), so it is never spawned to
+ * ask — the version is read off the install's own `<major>.<minor>.<build>.<patch>`
+ * folder instead, and an install without one answers this.
+ */
+export const WINDOWS_VERSION_UNKNOWN = "version unknown";
+/**
+ * How long a failed executable run waits before its one bounded retry. The
+ * failure this answers is not "nothing is installed here" — it is a host that
+ * is not ready yet at the moment the run fires (a WSL boot whose interop
+ * mount has not been served yet, a drive not yet mounted). Without the retry
+ * that answer would stand until someone fired the run again by hand.
+ */
+export const DISCOVERY_RETRY_DELAY_MS = 15000;
+/** How many retries one run chain may arm. Bounded so a machine with nothing
+ * installed is never probed forever — four passes span a boot window, and the
+ * manual trigger stays the answer beyond it. */
+export const DISCOVERY_RETRY_MAX = 4;
+/**
+ * Why a Windows `chrome.exe` on a WSL host is **never probed** — and, since the
+ * Windows executables this host carries *are* offered as candidates, what such a
+ * candidate reads as instead of a failure. The exec answers successfully — which
+ * is what makes the selection look healthy — but answering means *attaching to
+ * the Windows browser session*, and that brings a browser instance up (measured
+ * on WSL2 + Google Chrome 153: `chrome.exe --version` spawns the browser process
+ * plus its crashpad handler). No tool call could ever drive what it started (the
+ * debug pipes do not cross the interop boundary), so the probe buys nothing and
+ * costs a running browser: the check answers nothing, and the scan keeps the
+ * entry visible carrying this reason — as its **note**, never as a failure,
+ * because the **Prelaunch Windows Chrome** run drives it in connect mode.
+ */
+export const WSL_WINDOWS_LAUNCH_ERROR = "Windows chrome.exe cannot be launched from WSL — run Prelaunch Windows Chrome to drive it in connect mode";
+/** Max length of a reported error line. */
+export const ERROR_CAP = 240;
+/**
+ * Log lines the bridge emits after a lost connection recovered — clear
+ * the captured connection error when one shows up.
+ */
+export const BRIDGE_RECONNECTED = /reconnected and re-synced tools/u;
+/** One bridge log level: the levels the captured wrapper shadows. */
+export const LOG_LEVELS = ["trace", "debug", "info", "warn", "error", "fatal"];
+/**
+ * Bridge console-output routing modes (mirrors the reference plugin's gateway
+ * stderr modes). "log" redirects the spawned child's stderr into a log file;
+ * "console" inherits it onto the dsh console.
+ */
+export const BRIDGE_STDERR_MODES = ["log", "console"];
+/** Modes accepted by the `stderrMode` user layer: also the empty string
+ * ("" → follow the row config `bridgeStderr`). */
+export const STDERR_MODE_FIELD_PATTERN = /^(?:log|console)?$/u;
+/** Row-config `bridgeStderrLog` accepts "" (the per-spawn default) or a
+ * POSIX absolute path; nothing else. */
+export const OPTIONAL_PATH_PATTERN = /^(?:\/[^\x00-\x1f\x7f]*|)$/u;
+/**
+ * The connection kinds this component registers with the manager's
+ * `mcpConnections` service. They are the
+ * component: the row stands up no bridge of its own any more, every live bridge
+ * is one of these connections.
+ *
+ * `chrome` — the local `chrome-devtools-mcp` bridge, what the row used to start
+ * for itself. `chrome-windows` — the Windows browser driven through the WSL
+ * interop mount (the run the **Prelaunch Windows Chrome** button answers with),
+ * async to launch. The ids are the contract with `servers` entries; the labels
+ * are what the picker lists. Neither kind caps its entries and neither carries
+ * a composer pill.
+ */
+export const KIND_ID_CHROME = "chrome";
+export const KIND_ID_WINDOWS = "chrome-windows";
+export const KIND_CHROME_LABEL = "Chrome MCP";
+export const KIND_CHROME_SUMMARY = "Runs `chrome-devtools-mcp` and launches a local Chrome. The executable and the flags are picked on the connection.";
+export const KIND_WINDOWS_LABEL = "Windows Chrome (WSL debug port)";
+export const KIND_WINDOWS_SUMMARY = "Opens the Windows Chrome through the WSL interop mount and connects to its debugging port. WSL only.";
+/**
+ * The keys one entry's `extra` carries for these kinds. They are a contract with
+ * the manager's entry editor: what the fields write is exactly what `resolve`
+ * reads back. `extraFlags` is a `lines` field, so its value is one flag per
+ * line joined by newlines (see ./kind.ts `parseFlagLines`).
+ */
+export const KIND_FIELDS = {
+    executable: "executable",
+    extraFlags: "extraFlags",
+    stderrMode: "stderrMode"
+};
+/**
+ * Whether the translation of a **standalone** row config has been offered and
+ * turned down. It is a volatile field of this
+ * row — what was refused is this row's configuration, so the dismissal lives
+ * here and nowhere else.
+ */
+export const MIGRATION_DISMISSED_FIELD = "migrationDismissed";
+/** One entry's extra flag lines joined the way a `lines` field stores them. */
+export const FLAG_LINE_SEPARATOR = "\n";
+/** Why the `chrome-windows` kind refuses an entry off WSL (spec §2: not-applicable). */
+export const NOT_WSL_ERROR = "This host is not a WSL instance: there is no Windows-side browser to drive — use the Chrome MCP kind instead";
+/**
+ * `chromePath` user layer: a filesystem path or a PATH-resolved name. Nothing
+ * travels through a shell here either, so the only hard constraint is that no
+ * control character reaches it; the length cap keeps one absurd value out of
+ * argv and out of the row's own patch layer.
+ */
+export const CHROME_PATH_PATTERN = /^[^\x00-\x1f\x7f]{0,4096}$/u;
+/** Upper bound of the **legacy** UI-authored custom-executable MRU (oldest
+ * drops off). The MRU is the older shape of the saved-executables list: a host
+ * whose settings still carry it folds its paths into the `executables` rows the
+ * first time the picker scans (see ./catalog.ts `mergeEntries`), after which the
+ * rows are the only source of saved executables. */
+export const CUSTOM_PATHS_CAP = 10;
+/** Longest display name a saved-executable row may carry — the `name` half is
+ * UI-only (what the pill and the dropdown render), the `id` half is what goes on
+ * the wire. */
+export const CATALOG_NAME_MAX_LENGTH = 200;
+/** Upper bound of the saved-executable rows, merged-list side: the tail drops
+ * off, so a scan that keeps discovering new ids cannot grow the persisted
+ * catalog without limit. */
+export const CATALOG_MAX_LENGTH = 50;
+/**
+ * The Windows-side Chrome/Edge executables this host carries. The
+ * **Prelaunch Windows Chrome** button locates through them, and — on a WSL host
+ * only — the executable run folds the ones this machine actually carries into its
+ * candidate list, so the picker can name the executable the run drives. They are
+ * never *probed* from here (`WSL_WINDOWS_LAUNCH_ERROR`): the run drives them in
+ * *connect* mode, which is the only Windows path ever measured to work. The list
+ * is host-served logic: the card carries no copy of it.
+ */
+export const WINDOWS_CHROME_CANDIDATES = [
+    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+    "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe"
+];
+/** The debugging port every Windows Chrome launch carries first — kept
+ * coherent with the port the **Flags WSL** control recommends. */
+export const WINDOWS_CHROME_PORT = 9222;
+/** The debugging-port pool the run falls through when the first port is already
+ * carrying a listener: [first, first+1, …]. A listener answers "reachable",
+ * which is what makes the port's own reachability sample its in-use signal. */
+export const WINDOWS_CHROME_PORT_POOL = [9222, 9223, 9224];
+/**
+ * Ports that **only Windows ever listens on** (RPC endpoint mapper, RDP). The
+ * prereq check connects one of them: on a `mirrored` networkingMode host the
+ * connect succeeds, on a NAT host it gives up — the sample must discriminate,
+ * which is exactly what makes it the prereq (measured: 135/3389 CONNECTED
+ * under mirrored, closed ports TIME OUT, never refuse). A port that WSL might
+ * hold locally (445 via Samba) must never be used: it would answer reachable
+ * even when the Windows loopback is unreachable.
+ */
+export const WINDOWS_CHROME_PREREQ_PORTS = [135, 3389];
+/** How long to wait for the launched Windows Chrome to open its port. */
+export const WINDOWS_CHROME_WAIT_MS = 10000;
+/** How long one TCP reachability sample waits before calling the port
+ * unreachable (a NAT host's closed port times out; it never refuses). */
+export const WINDOWS_CHROME_SAMPLE_MS = 1000;
+/** Poll cadence while waiting for a launched Windows Chrome to bind its port. */
+export const WINDOWS_CHROME_POLL_MS = 500;
+/**
+ * The Windows-side working directory the launch runs with. Nothing depends on
+ * it (every argument is absolute), it only keeps relative path resolution off
+ * any UNC (WSL-side) path — the shape the old `cmd.exe /c start` form needed
+ * too (measured 2026-10-04, see .probe/windows-chrome-connect-probe.log).
+ */
+export const WINDOWS_CHROME_START_CWD = "/mnt/c/Windows";
+/** The UNC root modern WSL exports to Windows-side processes. */
+export const WSL_UNC_ROOT = "\\\\wsl.localhost\\";
+/**
+ * The Windows-side directory name the run profiles under
+ * (`%LOCALAPPDATA%\dsh-chrome-mcp\<.chrome|\.chrome-<port>>`). The profile
+ * must live on the Windows filesystem: the WSL-side directories, served to
+ * Windows through 9P, cannot carry the locks Chrome's SQLite tables and its
+ * singleton socket take — a profile rooted there opens every table as a
+ * zero-byte file and shows "an error occurred while opening your profile" on
+ * every launch (measured live 2026-10-04 against Chrome 154). The workspace
+ * keeps a `.chrome` view of this directory through the link the run refreshes
+ * (see `linkWindowsChromeProfile`).
+ */
+export const WINDOWS_CHROME_PROFILE_DIRNAME = "dsh-chrome-mcp";
+/** The connect-mode flag the button writes; its value is the debugging URL. */
+export const BROWSER_URL_FLAG_PREFIX = "--browserUrl=";
+/**
+ * The flags a brand-new Windows profile is launched with, beside the port and
+ * the profile directory. A fresh `--user-data-dir` IS a first run for the
+ * browser: Windows Chrome opens the welcome tab and the default-search-engine
+ * chooser on it, and in connect mode nothing clicks through it — the debugging
+ * session is left sitting on the FRE page. Both flags suppress that
+ * experience, exactly like the manual recipe the button replaces. They travel
+ * on the **browser's own** argv (the `start` line), never as `--chromeArg=`:
+ * here it is Chrome being told at launch what not to show, not the bridge
+ * parser (see the browser-switches bullet under Hard constraints).
+ */
+export const WINDOWS_CHROME_FIRST_RUN_FLAGS = ["--no-first-run", "--no-default-browser-check"];
+/**
+ * The page the Windows launch opens, package-root-relative. It is the one asset
+ * this plugin ships outside `lib`, and it is **read host-side**: the run renders
+ * it with its own answers, writes it through the interop mount next to the
+ * profile directory (so the Windows-side browser can actually read it), and hands
+ * the browser the `file:///…` URL. It exists because the honest answer to "why
+ * did a window just open?" is prose the argv cannot carry — and the usual
+ * placeholder is not an option: `example.com` carries an explicit notice against
+ * being used for automation and tests.
+ */
+export const WINDOWS_CHROME_LANDING_ASSET = "assets/prelaunch-windows-chrome.html";
+/** The base name of the landing file written beside each profile directory
+ * (`…\dsh-chrome-mcp\prelaunch-<port>.html`) — a sibling of the profile, never a
+ * file inside it, so it never reads as profile churn. */
+export const WINDOWS_CHROME_LANDING_BASENAME = "prelaunch";
+/** What one Windows Chrome run may currently be doing (the card derives its
+ * button state, pill muting and disabled reason from this single field).
+ * `"not-applicable"` is the non-WSL answer the plan asks the button to read as
+ * disabled-off; `"launch-failed"` and the rest are the §4 failure states. */
+export const WINDOWS_CHROME_STATES = [
+    "off",
+    "launching",
+    "connected",
+    "unreachable",
+    "not-found",
+    "launch-failed",
+    "not-applicable"
+];
+/** Schema pattern for `windowsChromeStatus.state`. */
+export const WINDOWS_CHROME_STATE_PATTERN = /^(?:off|launching|connected|unreachable|not-found|launch-failed|not-applicable)$/u;
+/**
+ * The prereq answer — the one manual step that is not the button's job
+ * (configuring `~/.wslconfig` is out of scope, reading/reaching it is not).
+ */
+export const WINDOWS_CHROME_PREREQ_ERROR = "Windows Chrome needs networkingMode=mirrored in %USERPROFILE%\\.wslconfig, then wsl --shutdown: today the Windows loopback is not reachable from this WSL host";
+/** Where the effective selection came from (`effectiveSource`): a `chromePath`
+ * written by the card (or seeded once by the host) or the row config. Nothing
+ * resolves on its own, so there is no "auto". */
+export const EFFECTIVE_SOURCES = ["selected", "row-config"];
+/**
+ * Environment variables WSL exports into every distro session. Their presence
+ * answers "are we running inside WSL?" — the first one carries the distro name,
+ * `WSL_INTEROP` the interop-path directory (`/run/WSL/<pid>`).
+ */
+export const WSL_ENV_VARS = ["WSL_DISTRO_NAME", "WSL_DISTRO_LABEL", "WSL_INTEROP"];
+/**
+ * The `binfmt_misc` registration WSL installs for PE binaries: its presence
+ * marks a WSL kernel. It is only the **fallback** signal — inside a host the
+ * launch environment is authoritative, and an empty one is an answer (see
+ * ./platform.ts).
+ */
+export const WSL_INTEROP_MARKER = "/proc/sys/fs/binfmt_misc/WSLInterop";
+/** Windows executables reachable through the interop mount (`/mnt/c/...`) or by
+ * their Windows spelling (UNC, drive letter). */
+export const WINDOWS_PATH_PATTERN = /^(?:\/mnt\/[a-z]\/|\\\\[\w.-]+\\|[a-z]:[\\/])/iu;
+/** The PE suffix. WSL execve's a `.exe` from any path (the Windows loader reads
+ * the Linux filesystem over UNC), so the suffix alone marks a Windows binary. */
+export const WINDOWS_EXE_PATTERN = /\.exe$/iu;
+/** Schema pattern for `effectiveSource` ("" = nothing resolved yet). */
+export const EFFECTIVE_SOURCE_PATTERN = /^(?:selected|row-config)?$/u;
+//# sourceMappingURL=constants.js.map

package/lib/host/constants.js.map

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

package/lib/host/controller/_trace.d.ts

@@ -0,0 +1,3 @@
+/** Trace one event. Never throws: diagnostics must not change behavior. */
+export declare function trace(event: Record<string, unknown>): void;
+//# sourceMappingURL=_trace.d.ts.map

package/lib/host/controller/_trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_trace.d.ts","sourceRoot":"","sources":["../../../src/host/controller/_trace.ts"],"names":[],"mappings":"AAMA,2EAA2E;AAC3E,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAM1D"}

package/lib/host/controller/_trace.js

@@ -0,0 +1,14 @@
+// TEMPORARY diagnostic: append one JSON line per traced event to a scratch
+// log so a live reproduction can be inspected without a browser console.
+import { appendFileSync } from "node:fs";
+const PATH = "/tmp/dsh-chrome-home/plugin-trace.log";
+/** Trace one event. Never throws: diagnostics must not change behavior. */
+export function trace(event) {
+    try {
+        appendFileSync(PATH, `${new Date().toISOString()} ${JSON.stringify(event)}\n`);
+    }
+    catch {
+        // Scratch home not writable — nothing to do.
+    }
+}
+//# sourceMappingURL=_trace.js.map

package/lib/host/controller/_trace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_trace.js","sourceRoot":"","sources":["../../../src/host/controller/_trace.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,yEAAyE;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC,MAAM,IAAI,GAAG,uCAAuC,CAAC;AAErD,2EAA2E;AAC3E,MAAM,UAAU,KAAK,CAAC,KAA8B;IAChD,IAAI,CAAC;QACD,cAAc,CAAC,IAAI,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACnF,CAAC;IAAC,MAAM,CAAC;QACL,6CAA6C;IACjD,CAAC;AACL,CAAC"}

package/lib/host/controller/bridge-run.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Controller — bridge switches.
+ *
+ * How a flag, executable or stderr-mode change reaches the running bridge: the
+ * logical argv is rebuilt through `bridgeConfig` for the current state and
+ * applied as a `fiber.update()`, chained on the fiber's own readiness so a
+ * switch that lands while the first connection is still loading actually takes
+ * effect (cordis restarts a fiber only from `ACTIVE`).
+ */
+import { bridgeConfig } from "../bridge.js";
+import type { BridgeStderrMode, ChromeMcpConfig } from "../types/index.js";
+import type { Controller } from "./state.js";
+/** The bridge's own view of one config: the ordinary passthroughs ride along
+ * verbatim, and the two levers the run owns — the flags list and the resolved
+ * selection — are handed in explicitly, so nothing here mistakes a reference for
+ * a value. The logical argv shape is unchanged. */
+export declare function configForBridge(controller: Controller, flags: string[]): ChromeMcpConfig;
+/**
+ * Restart the bridge connection with one built config.
+ *
+ * A cordis fiber restarts only from `ACTIVE`: an `update` issued while the
+ * bridge's first connection is still loading is stored but never applied (the
+ * load in flight resolves with the config it started with), and the update
+ * settles `undefined` as if it had worked — so the bridge would silently keep
+ * running with the argv it first spawned with. Chaining the update onto the
+ * fiber's own readiness (the returned thenable settles with the load) is what
+ * makes the switches that land while the bridge is still starting — the first
+ * ones the saved connect-mode flags produce — actually take effect.
+ */
+export declare function restartBridge(controller: Controller, built: ReturnType<typeof bridgeConfig>, note: string): void;
+/** Re-apply the nested bridge with one flags list; failures logged, never thrown. */
+export declare function applyFlags(controller: Controller, flags: string[]): void;
+/**
+ * Switch the effective bridge stderr mode in place — the card's "Reduce log
+ * output" toggle. Only the spawn wrapper changes, but that means restarting the
+ * bridge connection (the stderr routing is fixed at spawn); the flags and the
+ * executable stay exactly as they were.
+ */
+export declare function applyStderrMode(controller: Controller, mode: BridgeStderrMode): void;
+//# sourceMappingURL=bridge-run.d.ts.map

package/lib/host/controller/bridge-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-run.d.ts","sourceRoot":"","sources":["../../../src/host/controller/bridge-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAI3E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;mDAGmD;AACnD,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,eAAe,CAExF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAgBhH;AAED,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAexE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,gBAAgB,GAAG,IAAI,CASpF"}

package/lib/host/controller/bridge-run.js

@@ -0,0 +1,85 @@
+/**
+ * Controller — bridge switches.
+ *
+ * How a flag, executable or stderr-mode change reaches the running bridge: the
+ * logical argv is rebuilt through `bridgeConfig` for the current state and
+ * applied as a `fiber.update()`, chained on the fiber's own readiness so a
+ * switch that lands while the first connection is still loading actually takes
+ * effect (cordis restarts a fiber only from `ACTIVE`).
+ */
+import { bridgeConfig } from "../bridge.js";
+import { flagsSkipCheck } from "../flags.js";
+import { noteStderr } from "./notes.js";
+import { publishLive } from "./publish.js";
+/** The bridge's own view of one config: the ordinary passthroughs ride along
+ * verbatim, and the two levers the run owns — the flags list and the resolved
+ * selection — are handed in explicitly, so nothing here mistakes a reference for
+ * a value. The logical argv shape is unchanged. */
+export function configForBridge(controller, flags) {
+    return { ...controller.config, extraFlags: flags, chromePath: controller.state.runningChromePath };
+}
+/**
+ * Restart the bridge connection with one built config.
+ *
+ * A cordis fiber restarts only from `ACTIVE`: an `update` issued while the
+ * bridge's first connection is still loading is stored but never applied (the
+ * load in flight resolves with the config it started with), and the update
+ * settles `undefined` as if it had worked — so the bridge would silently keep
+ * running with the argv it first spawned with. Chaining the update onto the
+ * fiber's own readiness (the returned thenable settles with the load) is what
+ * makes the switches that land while the bridge is still starting — the first
+ * ones the saved connect-mode flags produce — actually take effect.
+ */
+export function restartBridge(controller, built, note) {
+    void Promise.resolve(controller.bridge)
+        .then(() => controller.bridge.update(built.config))
+        .then(() => {
+        // A successful bridge update proves the flags landed and the
+        // bridge connected again — it clears the captured *connection*
+        // error — but it says nothing about the executable: the known
+        // executable-missing answer stands until a probe answers a
+        // version or a tool call succeeds.
+        if (!controller.state.live.chromeMissing)
+            controller.state.live.lastError = "";
+        publishLive(controller);
+        // Intentionally NOT clearing `chromeMissing`: a successful bridge
+        // update proves the flags took but says nothing about the
+        // executable.
+    })
+        .catch((error) => controller.ctx.logger.error(`chrome-devtools-mcp(${controller.config.serverName}): ${note}: ${String(error)}`));
+}
+/** Re-apply the nested bridge with one flags list; failures logged, never thrown. */
+export function applyFlags(controller, flags) {
+    const { state } = controller;
+    state.runningFlags = flags;
+    // No mirror answer here: `publishLive` below re-derives it from the list the
+    // bridge launches with (`src/host/controller/publish.ts`), so setting it off
+    // this call's argument would be the same answer twice. The known-error gate
+    // reads the predicate directly for the same reason.
+    // Connect mode launches no local executable, so the known "executable
+    // missing" state simply does not apply while it is set.
+    if (flagsSkipCheck(flags))
+        state.live.chromeMissing = false;
+    publishLive(controller);
+    controller.ctx.logger.info(`chrome-devtools-mcp(${controller.config.serverName}): relaunching bridge with flags [${flags.join(" ")}]`);
+    const built = bridgeConfig(configForBridge(controller, flags), flags, state.runningStderrMode);
+    noteStderr(controller, built);
+    restartBridge(controller, built, "flags update failed");
+}
+/**
+ * Switch the effective bridge stderr mode in place — the card's "Reduce log
+ * output" toggle. Only the spawn wrapper changes, but that means restarting the
+ * bridge connection (the stderr routing is fixed at spawn); the flags and the
+ * executable stay exactly as they were.
+ */
+export function applyStderrMode(controller, mode) {
+    const { state } = controller;
+    state.runningStderrMode = mode;
+    state.live.stderrEffective = mode;
+    publishLive(controller);
+    controller.ctx.logger.info(`chrome-devtools-mcp(${controller.config.serverName}): bridge stderr mode → "${mode}" (restarting the bridge connection)`);
+    const built = bridgeConfig(configForBridge(controller, state.runningFlags), state.runningFlags, mode);
+    noteStderr(controller, built);
+    restartBridge(controller, built, `bridge stderr mode switch to "${mode}" failed`);
+}
+//# sourceMappingURL=bridge-run.js.map

package/lib/host/controller/bridge-run.js.map

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

package/lib/host/controller/captures.d.ts

@@ -0,0 +1,15 @@
+import type { Controller } from "./state.js";
+/**
+ * Register the tool-call status capture: browser-level failures surface only as
+ * the calling agent's tool result, never on a line, so a settled result whose
+ * registered name is prefixed `mcp__<id>__` for one of this component's live
+ * connections and carries `isError` writes the failure into the live mirror; a
+ * successful chrome-tool call clears both, so the card reports current health.
+ * A success is *evidence* — what a missing selection never produces — while an
+ * unrelated failure line never displaces the known executable-missing answer
+ * standing (the rule the old bridge-log capture followed too). The body is
+ * wrapped in try/catch (warn only — a capture fault must never break a tool
+ * call) and returns `next()` unchanged.
+ */
+export declare function registerToolCapture(controller: Controller): void;
+//# sourceMappingURL=captures.d.ts.map

package/lib/host/controller/captures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captures.d.ts","sourceRoot":"","sources":["../../../src/host/controller/captures.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAkBhE"}

package/lib/host/controller/captures.js

@@ -0,0 +1,85 @@
+/**
+ * Controller — the tool-call result capture that reaches the live mirror.
+ *
+ * A settled browser-tool result that failed becomes the newest `lastError`,
+ * classified into the known "executable missing" flag so the single red status
+ * dot keeps its whole story. The write is a live mirror write: published through
+ * the references, never persisted.
+ *
+ * What the bridge-log capture used to be, the connection lines are now: every
+ * failure the nested fiber answers with reaches the manager's own line for the
+ * entry that spawned it, and the tool-call surface is the one failure path that
+ * never reaches any line — a browser-level problem (target closed, dialog stuck,
+ * protocol timeout) is returned to the calling agent and lands nowhere else.
+ * Hence only the tool capture survives here.
+ *
+ * The prefix rule changed with the component model: a connection publishes under
+ * `mcp__<entry id>__`, where the entry id is the manager's, not the row's old
+ * `serverName`. So the capture answers for whichever live connection of this
+ * component's own kinds carries the tool; a tool outside this component's
+ * namespace never touches the mirror.
+ */
+import { captureToolResults } from "@comecaramelos/dsh-ancesters/host";
+import { isChromeMissing } from "../status.js";
+import { publishLive } from "./publish.js";
+/**
+ * Register the tool-call status capture: browser-level failures surface only as
+ * the calling agent's tool result, never on a line, so a settled result whose
+ * registered name is prefixed `mcp__<id>__` for one of this component's live
+ * connections and carries `isError` writes the failure into the live mirror; a
+ * successful chrome-tool call clears both, so the card reports current health.
+ * A success is *evidence* — what a missing selection never produces — while an
+ * unrelated failure line never displaces the known executable-missing answer
+ * standing (the rule the old bridge-log capture followed too). The body is
+ * wrapped in try/catch (warn only — a capture fault must never break a tool
+ * call) and returns `next()` unchanged.
+ */
+export function registerToolCapture(controller) {
+    // The listener, the prefix match, the note and the never-break-a-tool-call
+    // wrapping are ancestros' `captureToolResults`; the prefixes are asked on
+    // every call, because the live connections come and go.
+    captureToolResults(controller.ctx, {
+        name: `dsh-chrome-mcp(${controller.config.serverName})`,
+        prefix: (name) => ownedToolPrefix(controller).some((prefix) => name.startsWith(prefix)),
+        onResult: (note) => {
+            if (note === null) {
+                controller.state.live.lastError = "";
+                controller.state.live.chromeMissing = false;
+            }
+            else if (isChromeMissing(note) || !controller.state.live.chromeMissing) {
+                controller.state.live.lastError = note;
+                controller.state.live.chromeMissing = isChromeMissing(note);
+            }
+            publishLive(controller);
+        }
+    });
+}
+/** The namespaces whose tool calls belong to this component: every live
+ * connection of the component's own kinds answers under its entry id. A tool
+ * named anywhere else (another component's connection, a core stdio entry) is
+ * simply not this component's business. */
+function ownedToolPrefixes(controller) {
+    const service = controller.state.connections;
+    if (service === void 0)
+        return [];
+    const prefixes = [];
+    try {
+        for (const entry of service.entries()) {
+            if (entry.kind !== "chrome" && entry.kind !== "chrome-windows")
+                continue;
+            prefixes.push(`mcp__${entry.id}__`);
+        }
+    }
+    catch {
+        return [];
+    }
+    return prefixes;
+}
+function ownedToolPrefix(controller) {
+    const prefixes = ownedToolPrefixes(controller);
+    // The row's own `serverName` still names the tools while the connection was
+    // answered under it (the migration-era config), so a captured tool under
+    // that namespace is also ours.
+    return prefixes.length > 0 ? prefixes : [`mcp__${controller.config.serverName}__`];
+}
+//# sourceMappingURL=captures.js.map

package/lib/host/controller/captures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"captures.js","sourceRoot":"","sources":["../../../src/host/controller/captures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAEvE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAG3C;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,mBAAmB,CAAC,UAAsB;IACtD,2EAA2E;IAC3E,0EAA0E;IAC1E,wDAAwD;IACxD,kBAAkB,CAAC,UAAU,CAAC,GAAY,EAAE;QACxC,IAAI,EAAE,kBAAkB,UAAU,CAAC,MAAM,CAAC,UAAU,GAAG;QACvD,MAAM,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAC/F,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE;YACf,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;gBAChB,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;gBACrC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;YAChD,CAAC;iBAAM,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;gBACvE,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;gBACvC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;YAChE,CAAC;YACD,WAAW,CAAC,UAAU,CAAC,CAAC;QAC5B,CAAC;KACJ,CAAC,CAAC;AACP,CAAC;AAED;;;2CAG2C;AAC3C,SAAS,iBAAiB,CAAC,UAAsB;IAC7C,MAAM,OAAO,GAAG,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC;IAC7C,IAAI,OAAO,KAAK,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAClC,MAAM,QAAQ,GAAa,EAAE,CAAC;IAC9B,IAAI,CAAC;QACD,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;YACpC,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,IAAI,KAAK,gBAAgB;gBAAE,SAAS;YACzE,QAAQ,CAAC,IAAI,CAAC,QAAQ,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;QACxC,CAAC;IACL,CAAC;IAAC,MAAM,CAAC;QACL,OAAO,EAAE,CAAC;IACd,CAAC;IACD,OAAO,QAAQ,CAAC;AACpB,CAAC;AAED,SAAS,eAAe,CAAC,UAAsB;IAC3C,MAAM,QAAQ,GAAG,iBAAiB,CAAC,UAAU,CAAC,CAAC;IAC/C,4EAA4E;IAC5E,yEAAyE;IACzE,+BAA+B;IAC/B,OAAO,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,UAAU,CAAC,MAAM,CAAC,UAAU,IAAI,CAAC,CAAC;AACvF,CAAC"}

package/lib/host/controller/commits.d.ts

@@ -0,0 +1,4 @@
+import type { Controller } from "./state.js";
+/** Route one configuration-form commit. */
+export declare function onFormCommit(controller: Controller): void;
+//# sourceMappingURL=commits.d.ts.map

package/lib/host/controller/commits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commits.d.ts","sourceRoot":"","sources":["../../../src/host/controller/commits.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,2CAA2C;AAC3C,wBAAgB,YAAY,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CA8FzD"}