@comecaramelos/dsh-chrome-mcp 0.0.1 → 2.0.0

package/lib/host/controller/commits.js

@@ -0,0 +1,131 @@
+/**
+ * Controller — configuration-form commit routing.
+ *
+ * One commit may carry any of five changes; this routes them in the reference's
+ * order: a flags drift shifts what a connection with no own answer would run
+ * with (and hands such live connections back to the pool), an executable change
+ * picked by the card does the same plus a re-run of the discovery, a rows change
+ * is folded into the same run (never a second one), the stderr toggle shifts the
+ * spawn wrapper the next answer builds with, and the two trigger nonces (the
+ * fetch button, the Windows button) fire their runs. The first commit read is
+ * the registration run — a persisted Windows trigger folds in silently so
+ * booting a host never launches a Windows browser by itself.
+ *
+ * Two things make this routing safe under the config-form model:
+ *
+ * - It runs only for **user-authored** paths (see ../settings.ts
+ *   `routesUserCommit`), so the live publish it itself triggers — a volatile
+ *   commit carrying live fields — never re-enters it.
+ * - It re-publishes the live mirror when it finishes. A user write clears the
+ *   live-only fields out of the running references (the write merge), so without
+ *   the re-publish the card would read defaults back until the next run.
+ *
+ * Nothing here restarts anything: what runs lives in the manager's pool, and
+ * that pool decides a restart against the config the kind's `resolve` answers
+ * with — this side only says what the default answers would be.
+ */
+import { normalizeEntries } from "../catalog.js";
+import { KIND_FIELDS } from "../constants.js";
+import { flagsSkipCheck, sameFlags } from "../flags.js";
+import { readPersistedChromePath, resolveLaunchFlags, resolveSelection, resolveStderrModeFromLayers } from "../values.js";
+import { invalidateOwnedForField } from "./connections.js";
+import { applyChromePath, queue, sameEntries } from "./runs.js";
+import { publishLive } from "./publish.js";
+/** Route one configuration-form commit. */
+export function onFormCommit(controller) {
+    const { state } = controller;
+    try {
+        const layers = state.source();
+        // Flags: the user layer, then the launch environment, then the row config,
+        // then the schema default. Whatever answers is what a connection following
+        // the row would run with; the ones carrying their own list are untouched.
+        const nextFlags = resolveLaunchFlags(layers, controller.launchFlags);
+        if (!sameFlags(nextFlags, state.runningFlags)) {
+            state.runningFlags = nextFlags;
+            // Connect mode launches no local executable, so the known "executable
+            // missing" state simply does not apply while it is set.
+            if (flagsSkipCheck(nextFlags))
+                state.live.chromeMissing = false;
+            publishLive(controller);
+            controller.ctx.logger.info(`dsh-chrome-mcp(${controller.config.serverName}): default flags → [${nextFlags.join(" ")}] (connections without own flags re-answer on the next prepare)`);
+            invalidateOwnedForField(controller, KIND_FIELDS.extraFlags);
+        }
+        // Executable changes come from the user layer `chromePath` the card wrote
+        // (a row's `id`) or the host seeded. A different executable reads a
+        // different machine: mirror the new default and re-run the discovery. A
+        // path the host seeded itself keeps standing until the user picks one:
+        // the seed is written into the user layer, and until that write is
+        // visible a commit must not resolve back to "nothing selected".
+        const userLayer = readPersistedChromePath(layers);
+        if (userLayer !== "")
+            state.seenUserSelection = true;
+        const seededCarry = state.seededPath !== "" && !state.seenUserSelection ? state.seededPath : "";
+        const selection = resolveSelection(layers);
+        const nextChromePath = selection.path !== "" ? selection.path : seededCarry;
+        const nextSource = nextChromePath === "" ? "" : selection.source !== "" ? selection.source : "selected";
+        // A row config that pinned the executable with a flag answers as the
+        // row-config source; say it once, since the fold is invisible to argv and
+        // a silent switch would read as the picker having changed.
+        if (selection.source === "row-config" && selection.pinned === true && !state.legacyPinAnnounced) {
+            state.legacyPinAnnounced = true;
+            controller.ctx.logger.warn(`dsh-chrome-mcp(${controller.config.serverName}): an extraFlags "--executablePath" in the row config is now the \`chromePath\` source ("${selection.path}"); the flag itself is dropped from the launched argv`);
+        }
+        if (nextChromePath !== state.runningChromePath || nextSource !== state.runningChromeSource)
+            applyChromePath(controller, nextChromePath, nextSource);
+        // Rows changes touch the list, never a connection.
+        const nextExecutables = normalizeEntries(layers.user.executables ?? layers.value.executables);
+        const rowsChanged = !sameEntries(nextExecutables, state.runningExecutables);
+        // The "Reduce log output" toggle lives here too: the effective stderr mode
+        // is stated from every commit, not only from a switch — a commit that
+        // changes nothing the spawn does must still answer what the spawn *does*
+        // do, or the card's own diff against the effective mode would drop every
+        // flip it stages. A switch shifts the default and hands the connections
+        // that follow it back to the pool (the wrapper is fixed at spawn).
+        const nextStderrMode = resolveStderrModeFromLayers(layers, controller.config.bridgeStderr);
+        state.live.stderrEffective = nextStderrMode;
+        if (nextStderrMode !== state.runningStderrMode) {
+            state.runningStderrMode = nextStderrMode;
+            publishLive(controller);
+            controller.ctx.logger.info(`dsh-chrome-mcp(${controller.config.serverName}): bridge stderr mode → "${nextStderrMode}" (connections re-spawn with the new wrapper)`);
+            invalidateOwnedForField(controller, KIND_FIELDS.stderrMode);
+        }
+        // A persisted trigger must never fire a run just because the Host read
+        // it back: the reference pins this with `!== 0` (a stored nonce folds in
+        // silently, only a later diff fires). The guard here is the same rule,
+        // stated the stronger way: the first commit *is* the fold (booting never
+        // launches — see the branch below), and every later diff is real because
+        // the card writes `Date.now()` as the trigger value (the client's
+        // fetch/openWindowsChrome), so no stored value ever equals a new write.
+        const firstCommit = state.lastRefreshNonce === void 0;
+        const refreshChanged = !firstCommit && layers.value.refreshExecutablesNonce !== state.lastRefreshNonce;
+        const windowsChanged = !firstCommit && layers.value.openWindowsChromeNonce !== state.lastWindowsNonce;
+        state.lastRefreshNonce = layers.value.refreshExecutablesNonce;
+        state.lastWindowsNonce = layers.value.openWindowsChromeNonce;
+        if (firstCommit) {
+            // The registration run: discovery + probe, no separate call. A
+            // persisted Windows trigger folds in silently — booting a host must
+            // never launch a Windows browser by itself.
+            queue(controller, "probe");
+        }
+        else {
+            // The card's **Fetch executables** button. A rows change is folded into
+            // the same run rather than a second one, so the client waits on exactly
+            // one revision bump.
+            if (refreshChanged || rowsChanged)
+                queue(controller, "probe");
+            // The card's **Prelaunch Windows Chrome** button: one Windows run,
+            // sharing this chain (one run at a time).
+            if (windowsChanged)
+                queue(controller, "windows");
+        }
+    }
+    catch (error) {
+        controller.ctx.logger.error(`dsh-chrome-mcp(${controller.config.serverName}): ${String(error)}`);
+    }
+    finally {
+        // Every user commit clears the live-only fields, so the mirror goes back
+        // out with the answers it carries.
+        publishLive(controller);
+    }
+}
+//# sourceMappingURL=commits.js.map

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

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

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

@@ -0,0 +1,38 @@
+import type { Controller } from "./state.js";
+/** Everything one `resolve` answered with that the live state should carry. */
+export interface RunningAnswers {
+    /** The executable the connection launches ("" in connect mode). */
+    executable: string;
+    /** Where it came from (`"selected"` / `"row-config"` / ""). */
+    source: string;
+    /** The flags list it launched with. */
+    flags: string[];
+    /** The console-output mode it spawned with. */
+    stderrMode: "log" | "console";
+    /** Where the stderr lands when the wrapper redirects ("" otherwise). */
+    redirect: string;
+    /** The note the answer carries ("" = silent). */
+    note: string;
+}
+/**
+ * Mirror what a live connection runs with into the live state and say it out
+ * loud: publish, then notify that the pickers' answers moved (their Host-served
+ * choices read this state off). One log line per resolve names the connection
+ * being answered for.
+ */
+export declare function noteRunning(controller: Controller, entryId: string, answers: RunningAnswers): void;
+/**
+ * Tell the pool to re-answer every live connection whose answer depends on the
+ * field the row just changed. A connection carrying its own `extra` answer for
+ * the field does not follow the row's default, so it is left standing; every
+ * other owned entry is handed back for a re-resolve, live ones included — the
+ * diff that decides what the pool actually does with the re-resolve is decided
+ * on the **resolved config**, so a connection that would answer with exactly
+ * what it runs with is not restarted anyway, and one that would answer with
+ * something else switches in place.
+ */
+export declare function invalidateOwnedForField(controller: Controller, fieldKey: string): void;
+/** The invalidation key matching one kind-field, shared by the three drift paths
+ * in ./commits.ts. */
+export declare const DEFAULT_ANSWER_FIELDS: readonly ["executable", "extraFlags", "stderrMode"];
+//# sourceMappingURL=connections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connections.d.ts","sourceRoot":"","sources":["../../../src/host/controller/connections.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,+EAA+E;AAC/E,MAAM,WAAW,cAAc;IAC3B,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,+CAA+C;IAC/C,UAAU,EAAE,KAAK,GAAG,SAAS,CAAC;IAC9B,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,IAAI,CAalG;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAYtF;AAED;sBACsB;AACtB,eAAO,MAAM,qBAAqB,qDAAoF,CAAC"}

package/lib/host/controller/connections.js

@@ -0,0 +1,71 @@
+/**
+ * Controller — the manager-connection seam.
+ *
+ * The row starts no bridge of its own any more: every live bridge is one of the
+ * manager's connections, answered through ./kind.ts (`resolve`). What this module
+ * keeps is the mirror half — when a connection answers with what it runs with,
+ * the live state says so (the running executable, the running flags, the stderr
+ * destination, the running note) — plus the write paths that change what the
+ * **default** answers would be: a row-level flags/executable/stderr edit has to
+ * reach the live connections that carry no own answer for that field, which the
+ * pool only learns about on the next `invalidate`.
+ *
+ * The old file this replaces drove the fiber directly (`bridgeConfig` rebuild,
+ * `fiber.update()` chained on readiness). The pool does that now, against the
+ * config a kind's `resolve` hands it.
+ */
+import { KIND_FIELDS } from "../constants.js";
+import { ownedEntries } from "../manager.js";
+import { noteStderr } from "./notes.js";
+import { publishLive } from "./publish.js";
+/**
+ * Mirror what a live connection runs with into the live state and say it out
+ * loud: publish, then notify that the pickers' answers moved (their Host-served
+ * choices read this state off). One log line per resolve names the connection
+ * being answered for.
+ */
+export function noteRunning(controller, entryId, answers) {
+    const { state } = controller;
+    state.runningFlags = [...answers.flags];
+    state.runningChromePath = answers.executable;
+    state.runningChromeSource = answers.source === "row-config" || answers.source === "selected" ? answers.source : "";
+    state.runningStderrMode = answers.stderrMode;
+    state.live.runningFlags = [...answers.flags];
+    state.live.runningNote = answers.note;
+    if (answers.redirect !== "")
+        noteStderr(controller, { redirect: answers.redirect });
+    controller.ctx.logger.info(`dsh-chrome-mcp(${entryId}): connection answers with executable "${answers.executable || "(connect mode)"}", flags [${answers.flags.join(" ")}], stderr → ${answers.stderrMode}${answers.note === "" ? "" : `, ${answers.note}`}`);
+    // The publish inside `publishLive` re-notifies the pickers: the answers that
+    // just moved are exactly what a `select` offers.
+    publishLive(controller);
+}
+/**
+ * Tell the pool to re-answer every live connection whose answer depends on the
+ * field the row just changed. A connection carrying its own `extra` answer for
+ * the field does not follow the row's default, so it is left standing; every
+ * other owned entry is handed back for a re-resolve, live ones included — the
+ * diff that decides what the pool actually does with the re-resolve is decided
+ * on the **resolved config**, so a connection that would answer with exactly
+ * what it runs with is not restarted anyway, and one that would answer with
+ * something else switches in place.
+ */
+export function invalidateOwnedForField(controller, fieldKey) {
+    const { state } = controller;
+    if (state.connections === void 0)
+        return;
+    try {
+        for (const entry of ownedEntries(state.connections)) {
+            if (Object.prototype.hasOwnProperty.call(entry.extra, fieldKey))
+                continue;
+            state.connections.invalidate(entry.id);
+        }
+    }
+    catch {
+        // A manager that has already gone away answers nothing; there is nothing
+        // to invalidate.
+    }
+}
+/** The invalidation key matching one kind-field, shared by the three drift paths
+ * in ./commits.ts. */
+export const DEFAULT_ANSWER_FIELDS = [KIND_FIELDS.executable, KIND_FIELDS.extraFlags, KIND_FIELDS.stderrMode];
+//# sourceMappingURL=connections.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connections.js","sourceRoot":"","sources":["../../../src/host/controller/connections.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAmB3C;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,UAAsB,EAAE,OAAe,EAAE,OAAuB;IACxF,MAAM,EAAE,KAAK,EAAE,GAAG,UAAU,CAAC;IAC7B,KAAK,CAAC,YAAY,GAAG,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACxC,KAAK,CAAC,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC;IAC7C,KAAK,CAAC,mBAAmB,GAAG,OAAO,CAAC,MAAM,KAAK,YAAY,IAAI,OAAO,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IACnH,KAAK,CAAC,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC;IAC7C,KAAK,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC7C,KAAK,CAAC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IACtC,IAAI,OAAO,CAAC,QAAQ,KAAK,EAAE;QAAE,UAAU,CAAC,UAAU,EAAE,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IACpF,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,kBAAkB,OAAO,0CAA0C,OAAO,CAAC,UAAU,IAAI,gBAAgB,aAAa,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,eAAe,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IAC9P,6EAA6E;IAC7E,iDAAiD;IACjD,WAAW,CAAC,UAAU,CAAC,CAAC;AAC5B,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,uBAAuB,CAAC,UAAsB,EAAE,QAAgB;IAC5E,MAAM,EAAE,KAAK,EAAE,GAAG,UAAU,CAAC;IAC7B,IAAI,KAAK,CAAC,WAAW,KAAK,KAAK,CAAC;QAAE,OAAO;IACzC,IAAI,CAAC;QACD,KAAK,MAAM,KAAK,IAAI,YAAY,CAAC,KAAK,CAAC,WAAW,CAAC,EAAE,CAAC;YAClD,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,QAAQ,CAAC;gBAAE,SAAS;YAC1E,KAAK,CAAC,WAAW,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC3C,CAAC;IACL,CAAC;IAAC,MAAM,CAAC;QACL,yEAAyE;QACzE,iBAAiB;IACrB,CAAC;AACL,CAAC;AAED;sBACsB;AACtB,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,WAAW,CAAC,UAAU,EAAE,WAAW,CAAC,UAAU,EAAE,WAAW,CAAC,UAAU,CAAU,CAAC"}

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

@@ -0,0 +1,35 @@
+import { type WindowsChromeRunOptions } from "../windows/index.js";
+import type { ChromeMcpConfig, PluginContext, WindowsChromeRun } from "../types/index.js";
+import type { Controller } from "./state.js";
+/** Public alias: the controller object the form, commands and kinds work
+ * through is the internal `Controller` type itself. */
+export type ChromeMcpController = Controller;
+/**
+ * Optional overrides for tests and diagnostics: the Windows Chrome run is the
+ * only half that reaches outside the process (it opens TCP sockets and spawns
+ * through the interop mount), so a wiring test replaces just this one — the same
+ * injectability rule every other platform half follows.
+ */
+export type ChromeMcpControllerDeps = {
+    runWindowsChrome?: (options: WindowsChromeRunOptions) => Promise<WindowsChromeRun>;
+    /** The Windows-side executables this host carries, in preference order. The
+     * machine half of the candidate fold — the real one locates through the
+     * interop mount; a test supplies the answer list it wants folded. */
+    windowsExecutables?: () => string[];
+    /** The platform the WSL probe reads; defaults to `process.platform`. A test
+     * that simulates a WSL host through its launch environment states `linux`
+     * here too — the environment alone never makes a Windows host WSL. */
+    platform?: NodeJS.Platform;
+};
+/**
+ * Build the live state for one row page. The controller is also the public
+ * surface (`ChromeMcpController` — the same object the form, the commands and
+ * the kinds work through); what each method does lives in the sibling modules.
+ * @param ctx - plugin context.
+ * @param config - the validated config `apply` received: every `.volatile()`
+ * field a reference rather than a value (read them through `readConfigField`).
+ * @param deps - optional host overrides (tests replace the Windows run;
+ * everything else resolves from this process).
+ */
+export declare function createChromeMcpController(ctx: PluginContext, config: ChromeMcpConfig, deps?: ChromeMcpControllerDeps): Controller;
+//# sourceMappingURL=controller.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../src/host/controller/controller.ts"],"names":[],"mappings":"AAmCA,OAAO,EAAyD,KAAK,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAY1H,OAAO,KAAK,EACR,eAAe,EAEf,aAAa,EACb,gBAAgB,EACnB,MAAM,mBAAmB,CAAC;AAU3B,OAAO,KAAK,EAAE,UAAU,EAAmB,MAAM,YAAY,CAAC;AAE9D;uDACuD;AACvD,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAAC;AAE7C;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,GAAG;IAClC,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACnF;;yEAEqE;IACrE,kBAAkB,CAAC,EAAE,MAAM,MAAM,EAAE,CAAC;IACpC;;0EAEsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;CAC9B,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,eAAe,EAAE,IAAI,GAAE,uBAA4B,GAAG,UAAU,CAgMrI"}

package/lib/host/controller/controller.js

@@ -0,0 +1,234 @@
+/**
+ * Host half — live state: `createChromeMcpController`.
+ *
+ * One controller per apply(): the live mirror the Host publishes, the serialized
+ * executable runs, the Windows run half, and the capture paths — tool-call
+ * results reaching the live mirror. Every live answer is written into
+ * `state.live` and published through the volatile references (see ./publish.ts);
+ * form commits route in through the controller methods, never the other way
+ * round.
+ *
+ * Since the component model, the controller starts nothing: every live bridge is
+ * a connection of the manager's, answered through ./kind.ts. What this half owns
+ * is the machine — the executable catalog and its runs, the Windows run, the
+ * layers, and the mirror — plus the seam the manager reads it through (the
+ * connection service sits on `state.connections`, installed by ../manager.ts).
+ *
+ * The executable state keeps the rule that there is no auto mode: the saved
+ * **rows** (`{ id: path, name: label }`) are what every picker lists, the
+ * *selection* is what the default answers run with, and a run refreshes both —
+ * it probes every candidate the rows and the row config carry, merges what it
+ * finds into the rows (names kept), and seeds a never-configured host exactly
+ * once. A fixed path that later breaks stays fixed and reads broken instead of
+ * being re-resolved.
+ *
+ * This file is only the assembly: it resolves the config-derived pieces, seeds
+ * the live mirror, and wires the public methods to the behavior modules that sit
+ * alongside it (see ./index.ts for the layout). Everything that actually *does*
+ * something lives there, not here.
+ */
+import { existsSync } from "node:fs";
+import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
+import { FLAGS_ENV_VAR, WSL_WINDOWS_LAUNCH_ERROR } from "../constants.js";
+import { flagsSkipCheck } from "../flags.js";
+import { isWindowsExecutablePath, isWindowsSubsystemForLinux } from "../platform.js";
+import { findWindowsChromeExecutables, runWindowsChromeConnect } from "../windows/index.js";
+import { createLiveMirror, readConfigForm, readConfigLayers, readDefaultExtraFlags, readWslExtraFlags, resolveEnvFlags, resolveLaunchFlags, resolveSelection, resolveStderrModeFromLayers } from "../values.js";
+import { registerToolCapture } from "./captures.js";
+import { noteRunning as mirrorRunning } from "./connections.js";
+import { onFormCommit } from "./commits.js";
+import { noteSelection } from "./notes.js";
+import { dismissMigration, } from "./persist.js";
+import { cancelDiscoveryRetry, prelaunchWindowsChrome, queue, selectChromePath } from "./runs.js";
+import { prelaunchWindowsForConnection } from "./windows-run.js";
+/**
+ * Build the live state for one row page. The controller is also the public
+ * surface (`ChromeMcpController` — the same object the form, the commands and
+ * the kinds work through); what each method does lives in the sibling modules.
+ * @param ctx - plugin context.
+ * @param config - the validated config `apply` received: every `.volatile()`
+ * field a reference rather than a value (read them through `readConfigField`).
+ * @param deps - optional host overrides (tests replace the Windows run;
+ * everything else resolves from this process).
+ */
+export function createChromeMcpController(ctx, config, deps = {}) {
+    // The Windows run half — injectable for tests, default is the real one (TCP
+    // samples + the interop launch).
+    const windowsChrome = typeof deps.runWindowsChrome === "function" ? deps.runWindowsChrome : runWindowsChromeConnect;
+    const launchEnvironment = launchEnvironmentOf(ctx);
+    const launchFlags = launchEnvironment.get(FLAGS_ENV_VAR)?.value;
+    // Where the plugin runs: a WSL host plus a Windows executable is a selection
+    // the local bridge can never launch (its debug pipes do not cross the interop
+    // boundary, and its debugging port stays on the Windows loopback). The launch
+    // environment is authoritative inside a host, so the answer is deterministic;
+    // a bare call falls back to the interop marker.
+    const wslHost = isWindowsSubsystemForLinux({ platform: deps.platform, env: (name) => launchEnvironment.get(name)?.value });
+    // The Linux half of the host: the executable candidate list models the
+    // stable-channel installs a Linux host carries, so this is what keys the
+    // executable-missing answer's advice (see runs.ts). WSL is the case with the
+    // Windows-side alternative next to it.
+    const linuxHost = process.platform === "linux";
+    // A path this host must never exec. There is only one: a Windows
+    // `chrome.exe` selected on a WSL host. Its `--version` probe answers (so the
+    // selection looks healthy) but answering attaches to the Windows browser
+    // session, and that **starts a browser instance** no tool call could drive —
+    // see WSL_WINDOWS_LAUNCH_ERROR. The runs keep such an entry visible carrying
+    // this reason; the probe answers nothing instead of paying for it.
+    const blockedForPlatform = (candidate) => wslHost && isWindowsExecutablePath(candidate) ? WSL_WINDOWS_LAUNCH_ERROR : "";
+    // The Windows-side executables this host carries, located through the interop
+    // mount. An executable run folds them into its candidate list so the picker
+    // can name the Windows browser the **Prelaunch Windows Chrome** run drives
+    // instead of hiding it. Being offered only, they are never spawned (see
+    // `blockedForPlatform`): an entry answers a note, never a version, and never
+    // seeds. Locating them is the machine half of the fold, injected the same way
+    // the run's own `exists` half is — a host off WSL answers nothing, and a
+    // machine that carries none of them answers nothing either.
+    const windowsExecutables = typeof deps.windowsExecutables === "function"
+        ? deps.windowsExecutables
+        : () => (wslHost ? findWindowsChromeExecutables(existsSync) : []);
+    // The configuration form's layers as they answer right now. The references
+    // resolve the user layer over the row config, so every answer here is the
+    // effective one; the two layers the "did the user say this, or is it the row
+    // config" distinction reads only answer once the form attaches, and the first
+    // commit read settles it.
+    const layers = readConfigLayers(config);
+    // Default launch flags (highest first): the user layer,
+    // `DSH_CHROME_MCP_FLAGS`, the row config, the schema default. What a
+    // connection with no own answer is resolved with starts on them.
+    const initialFlags = resolveLaunchFlags(layers, launchFlags);
+    if (typeof launchFlags === "string" && launchFlags.trim() !== "" && resolveEnvFlags([], launchFlags).length === 0) {
+        ctx.logger.warn(`dsh-chrome-mcp(${config.serverName}): ignoring ${FLAGS_ENV_VAR} — invalid flags list; using the resolved configuration`);
+    }
+    // The initial selection: what the user layer says, else what the row config
+    // says (a legacy row-level `--executablePath` folded in — the picker owns that
+    // flag, so it becomes the row-config source of the selection and never reaches
+    // argv as a second source of truth), else nothing. Nothing here consults
+    // discovery: the first run does, and only seeds when both layers are silent.
+    const selection = resolveSelection(layers);
+    const runningChromePath = selection.path;
+    const runningChromeSource = selection.source;
+    // The effective console-output mode: what the user layer's toggle says, then
+    // what the row config carries, then the row's `bridgeStderr`. Every spawn
+    // wrapper reads it.
+    const runningStderrMode = resolveStderrModeFromLayers(layers, config.bridgeStderr);
+    // The mirror's opening answers: what the default answers would run with, not
+    // what a host with no answers would serve. `windowsChromeStatus` in particular
+    // reads off this host from the start — the Windows path simply does not exist
+    // off WSL.
+    const live = createLiveMirror();
+    live.effectiveChromePath = runningChromePath;
+    live.effectiveSource = runningChromeSource;
+    live.stderrEffective = runningStderrMode;
+    live.wslWindowsExecutable = wslHost && runningChromePath !== "" && isWindowsExecutablePath(runningChromePath);
+    live.carriesConnectionMode = flagsSkipCheck(initialFlags);
+    live.windowsChromeStatus = { state: wslHost ? "off" : "not-applicable", port: 0, error: "" };
+    live.defaultExtraFlags = readDefaultExtraFlags();
+    live.wslExtraFlags = readWslExtraFlags();
+    const state = {
+        live,
+        form: void 0,
+        // The live layers read: the references answer what runs now, and once the
+        // form is described the two layers answer the distinction with it. This is
+        // read live on every commit — cordis starts the `settings` injection
+        // callback after `apply` returns, so nothing may be captured here.
+        source: () => readConfigLayers(config, state.form?.settings ? readConfigForm(state.form.settings, state.form.entryId) : void 0),
+        runningFlags: initialFlags,
+        runningStderrMode,
+        runningChromePath,
+        runningChromeSource,
+        runningExecutables: [],
+        stderrNotice: "",
+        lastRefreshNonce: void 0,
+        lastWindowsNonce: void 0,
+        seededPath: "",
+        seenUserSelection: false,
+        runs: Promise.resolve(),
+        retryTimer: void 0,
+        retriesPending: 0,
+        disposed: false,
+        wslNoticeShown: false,
+        profileLinkKeptShown: false,
+        legacyPathsMerged: false,
+        legacyPinAnnounced: false,
+        mirror: void 0,
+        kindsNotifyQueued: false,
+        // The manager seam opens empty: `attachToManager` fills it in once the
+        // service answers. A component without the manager answers its own page
+        // and starts nothing — exactly as a row with no connections should.
+        connections: void 0,
+        notifyKindsChanged: () => void 0
+    };
+    const controller = {
+        ctx,
+        config,
+        wslHost,
+        linuxHost,
+        blockedForPlatform,
+        launchFlags,
+        windowsChrome,
+        windowsExecutables,
+        state,
+        attachForm(form) {
+            state.form = form;
+            const nowDescribed = form.settings !== void 0;
+            // The first attach is the mount's commit read: no nonce has been
+            // observed yet, so its nonce diff fires the registration run. The step
+            // where the row starts being *described* is routed too, for the one
+            // thing the references cannot answer: which layer a value came from.
+            // Until it answers there, the launch environment sits above whatever
+            // the references carry, so a saved UI edit has to be re-read against
+            // the user layer the moment that layer exists.
+            const first = !routed;
+            const layersArrived = nowDescribed && !described;
+            routed = true;
+            described = nowDescribed;
+            if (!first && !layersArrived)
+                return;
+            onFormCommit(controller);
+        },
+        detachForm() {
+            // Only the described row's layers go away: the references keep
+            // answering, so nothing else has to be undone.
+            state.form = void 0;
+            routed = false;
+            described = false;
+        },
+        onFormCommit: () => onFormCommit(controller),
+        run: () => queue(controller, "probe"),
+        source: () => state.source(),
+        // The live mirror, by reference: controller modules write its fields in
+        // place, publish reads them off `state.live`, and every other surface
+        // (the commands) reads the very same answers out of it.
+        get live() {
+            return state.live;
+        },
+        selectChromePath: (path) => selectChromePath(controller, path),
+        prelaunchWindowsChrome: () => prelaunchWindowsChrome(controller),
+        noteRunning(entry, answers) {
+            mirrorRunning(controller, entry.id, answers);
+        },
+        prelaunchForConnection: () => prelaunchWindowsForConnection(controller),
+        dismissMigration: () => dismissMigration(controller),
+        dispose: () => {
+            // Every late answer stands down: the run chain drains on its own (the
+            // chain is per-instance, no shared resource left behind), and the one
+            // timer this instance owns is cancelled.
+            state.disposed = true;
+            cancelDiscoveryRetry(controller);
+        }
+    };
+    // Form routing arrives in two steps — the entry id as soon as this fiber knows
+    // its own entry, then the described row once the settings service resolves —
+    // and the layers read live off it either way (the two flags above are what
+    // mark the difference between "never described" and "described before").
+    let routed = false;
+    let described = false;
+    // Tool-level status: browser-level failures are returned to the calling agent
+    // and never reach a line of their own.
+    registerToolCapture(controller);
+    // Seed the mirror before the first snapshot lands (a card that reads before
+    // anything ran still gets the real opening answers, never defaults).
+    noteSelection(controller);
+    return controller;
+}
+//# sourceMappingURL=controller.js.map

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

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

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

@@ -0,0 +1,30 @@
+/**
+ * Host half — the controller's live state + behavior.
+ *
+ * One controller per apply(): the live mirror the Host publishes, the serialized
+ * executable runs, the Windows run half, and the tool-call capture path. The
+ * public surface is `createChromeMcpController` (the controller object itself);
+ * everything behind it is split into concern modules:
+ *
+ *   ./controller.ts   the assembly: resolve config, seed the live mirror, wire
+ *                     the public methods
+ *   ./state.ts        the live state + context every helper shares (internal)
+ *   ./notes.ts        live-mirror announcements (selection, stderr)
+ *   ./connections.ts  the manager seam: what answers reach the live state, and
+ *                     how a default answer change reaches live connections
+ *   ./runs.ts         the executable run + serialization + the Windows trigger
+ *   ./windows-run.ts  the one **Prelaunch Windows Chrome** run
+ *   ./persist.ts      the form writes a run makes (seed, rows, dismissal)
+ *   ./captures.ts     tool-call-result capture
+ *   ./commits.ts      configuration-form commit routing (`onFormCommit`)
+ *
+ * The two rules that must survive the split: read the layers through
+ * `state.source()` at commit time, never capture them, and route every live answer
+ * out through `publishLive` (./publish.ts) — configuration-form commits route in,
+ * never out, and the live mirror is never written by a commit path.
+ */
+export { createChromeMcpController } from "./controller.js";
+export type { ChromeMcpController, ChromeMcpControllerDeps } from "./controller.js";
+export type { Controller, ControllerState } from "./state.js";
+export type { RunningAnswers } from "./connections.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/host/controller/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,YAAY,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AACpF,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC9D,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/lib/host/controller/index.js

@@ -0,0 +1,27 @@
+/**
+ * Host half — the controller's live state + behavior.
+ *
+ * One controller per apply(): the live mirror the Host publishes, the serialized
+ * executable runs, the Windows run half, and the tool-call capture path. The
+ * public surface is `createChromeMcpController` (the controller object itself);
+ * everything behind it is split into concern modules:
+ *
+ *   ./controller.ts   the assembly: resolve config, seed the live mirror, wire
+ *                     the public methods
+ *   ./state.ts        the live state + context every helper shares (internal)
+ *   ./notes.ts        live-mirror announcements (selection, stderr)
+ *   ./connections.ts  the manager seam: what answers reach the live state, and
+ *                     how a default answer change reaches live connections
+ *   ./runs.ts         the executable run + serialization + the Windows trigger
+ *   ./windows-run.ts  the one **Prelaunch Windows Chrome** run
+ *   ./persist.ts      the form writes a run makes (seed, rows, dismissal)
+ *   ./captures.ts     tool-call-result capture
+ *   ./commits.ts      configuration-form commit routing (`onFormCommit`)
+ *
+ * The two rules that must survive the split: read the layers through
+ * `state.source()` at commit time, never capture them, and route every live answer
+ * out through `publishLive` (./publish.ts) — configuration-form commits route in,
+ * never out, and the live mirror is never written by a commit path.
+ */
+export { createChromeMcpController } from "./controller.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/host/controller/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC"}