@reticlehq/init 2.14.0

package/dist/csp-check.js

@@ -0,0 +1,168 @@
+/**
+ * Does this app's Content-Security-Policy let the browser reach the Reticle bridge?
+ *
+ * Two independent field reports, both Next: `init` reported every step successful, the SDK mounted,
+ * the dial URL was correct, and the app never connected because a strict `connect-src` excluded
+ * `ws://localhost:<port>`. The browser blocks the WebSocket and says so in its own console, which
+ * nothing on the Reticle side reads — so `status` and `doctor` reported perfect health at an app
+ * that could not connect at all, forever. A setup step that exits 0 while leaving the user broken is
+ * the worst failure mode this repo has.
+ *
+ * A TEXT SCAN, deliberately. `headers()` is a function; `init` cannot execute a user's Next config
+ * without importing their whole app, and the thing worth finding is the policy string a developer
+ * typed — in `next.config.*`, in middleware, or in a `<meta http-equiv>` tag. The scan finds the
+ * string wherever it is written.
+ *
+ * NARROW on purpose: it fires only when a `connect-src` exists AND does not admit the bridge. No
+ * CSP, or one that already covers us, produces nothing. A warning that fires on a working setup
+ * costs precisely what a green check on a broken one costs, and this file exists because of the
+ * second kind.
+ */
+/** Sources that admit any ws origin, so the bridge is already reachable. */
+const WILDCARDS = ['*', 'ws:', 'wss:', 'ws://*', 'https:'];
+/** The two hosts the SDK may dial. `localhost` and the IPv4 loopback are different CSP sources. */
+function bridgeOrigins(port) {
+    return [`ws://localhost:${String(port)}`, `ws://127.0.0.1:${String(port)}`];
+}
+/**
+ * The `connect-src` directive's source list, or undefined when the text declares none.
+ *
+ * Matches to the end of the directive (`;`) or the end of the enclosing quoted string, which is how
+ * these are written in both a Next `headers()` value and a `<meta content="...">`.
+ */
+function directiveSources(text, directive) {
+    // Stops at the directive separator or the closing double quote of the enclosing string. Single
+    // quotes are NOT terminators: `'self'` is a source, not the end of the list.
+    const match = new RegExp(`${directive}([^;"]*)`, 'i').exec(text);
+    const list = match?.[1];
+    if (list === undefined)
+        return undefined;
+    return list
+        .split(/\s+/)
+        .map((source) => source.trim())
+        .filter((source) => source.length > 0);
+}
+/**
+ * What this policy allows a WebSocket to reach — `connect-src`, or `default-src` when it is absent.
+ *
+ * The fallback is the CSP spec's, and leaving it out made the check blind to the commonest strict
+ * policy there is. MarkText, a production Electron editor, declares
+ * `default-src 'self'; script-src 'self'; …` with NO `connect-src`: its WebSockets are restricted to
+ * 'self', the bridge is blocked, and this returned "no problem" because it was looking for a
+ * directive that was not written. Every fetch-directive falls back to `default-src`; that is what
+ * `default` means, and it is why an author does not repeat themselves.
+ *
+ * Still undefined when NEITHER is present — a policy that constrains neither is not blocking us.
+ */
+function connectSrcSources(text) {
+    return directiveSources(text, 'connect-src') ?? directiveSources(text, 'default-src');
+}
+/**
+ * The problem with this app's `connect-src`, or undefined if there is not one.
+ *
+ * `https:` counts as a wildcard here only in the sense that a policy written that loosely will not
+ * be the thing blocking a dev WebSocket; the check stays quiet rather than arguing about it.
+ */
+export function cspConnectSrcProblem(text, port) {
+    const sources = connectSrcSources(text);
+    if (sources === undefined || 0 === sources.length)
+        return undefined;
+    if (sources.some((source) => WILDCARDS.includes(source)))
+        return undefined;
+    const wanted = bridgeOrigins(port);
+    // BOTH, not either: the SDK picks its host from how the page was served, and a policy that admits
+    // one is a coin flip. A coin flip that fails is indistinguishable from every other silent
+    // non-connect, which is the whole cost being avoided here.
+    if (wanted.every((origin) => sources.includes(origin)))
+        return undefined;
+    const missing = wanted.filter((origin) => !sources.includes(origin));
+    return (`this app declares a Content-Security-Policy whose \`connect-src\` does not admit the Reticle ` +
+        `bridge: ${missing.join(' and ')} ${1 === missing.length ? 'is' : 'are'} missing. The browser ` +
+        `will block the WebSocket and report it in ITS console only — every check on the Reticle side ` +
+        `will pass while the app never connects. ${devCspAddition(port)}`);
+}
+/**
+ * What this policy allows a SCRIPT to be — `script-src`, or `default-src` when it is absent.
+ *
+ * Same fallback and same reason as {@link connectSrcSources}: every fetch-directive falls back to
+ * `default-src`, which is why an author writing `default-src 'self'` does not repeat themselves.
+ */
+function scriptSrcSources(text) {
+    return directiveSources(text, 'script-src') ?? directiveSources(text, 'default-src');
+}
+/**
+ * Would this policy stop the pasted connect snippet from RUNNING?
+ *
+ * The `connect-src` check above assumes the SDK got as far as opening a socket. Under a policy
+ * without `'unsafe-inline'` it never does: the snippet `init` prints is an inline
+ * `<script type="module">`, the browser refuses to execute it, and there is no SDK, no socket and
+ * nothing for `connect-src` to block. `reticle open` then reports "no session / app carries no SDK",
+ * which sends diagnosis at the wrong cause entirely (#679).
+ *
+ * The rule is the spec's, not a guess:
+ *
+ * - `'unsafe-inline'` is the ONLY source that admits an inline script. `*` does not — a host
+ *   wildcard says nothing about inline code, and reading it as permission is the commonest CSP
+ *   misconception there is.
+ * - a nonce, a hash, or `'strict-dynamic'` makes browsers IGNORE `'unsafe-inline'` entirely. A
+ *   policy carrying both is a policy that blocks inline scripts, and one carrying a nonce blocks
+ *   ours specifically: the nonce is minted for the app's own tags, not for a snippet pasted in by
+ *   hand.
+ */
+function blocksInlineScript(sources) {
+    const overridesUnsafeInline = sources.some((source) => source.startsWith("'nonce-") || source.startsWith("'sha") || "'strict-dynamic'" === source);
+    if (overridesUnsafeInline)
+        return true;
+    return !sources.includes("'unsafe-inline'");
+}
+/**
+ * The problem with this app's `script-src`, or undefined if there is not one.
+ *
+ * Reports the remedy that works under `'self'` — serve the connect code as an external module file —
+ * rather than telling anyone to weaken their policy with `'unsafe-inline'`.
+ */
+export function cspInlineScriptProblem(text, port) {
+    const sources = scriptSrcSources(text);
+    if (sources === undefined || 0 === sources.length)
+        return undefined;
+    if (!blocksInlineScript(sources))
+        return undefined;
+    return (`this app declares a Content-Security-Policy whose \`script-src\` does not admit an inline ` +
+        `script, so the connect snippet never executes. Nothing on the Reticle side can see this: with ` +
+        `no SDK there is no socket, and \`reticle open\` reports "no session / app carries no SDK" — ` +
+        `the wrong cause. ${externalScriptRemedy()} ${devCspAddition(port)}`);
+}
+/** Where the external connect module goes, for an app served from a static directory. */
+export const EXTERNAL_CONNECT_PATH = 'public/reticle-connect.js';
+/** The remedy that works under `script-src 'self'`, as text to copy. */
+export function externalScriptRemedy() {
+    return (`Serve the connect code as an EXTERNAL module instead: put it in ` +
+        `\`${EXTERNAL_CONNECT_PATH}\` and reference it with ` +
+        `\`<script type="module" src="/reticle-connect.js"></script>\`, which \`script-src 'self'\` ` +
+        `already allows. Note that an external module is DEFERRED, so the app's own classic scripts run ` +
+        `first and requests they fire before the SDK attaches are not observed.`);
+}
+/** The exact addition to paste. Text to copy, not advice to interpret. */
+export function devCspAddition(port) {
+    return (`Add to \`connect-src\` in development only (e.g. behind ` +
+        `\`process.env.NODE_ENV === 'development'\`): ` +
+        `${bridgeOrigins(port).join(' ')}`);
+}
+/** The step title, named here so `doctor` and the plan cannot drift apart on what this check is called. */
+export const CSP_STEP_TITLE = 'Content-Security-Policy';
+/**
+ * The first blocking policy among the sources `init` already has in hand, or undefined.
+ *
+ * At most one finding: a second copy of the same policy in a second file is the same problem, and
+ * two identical notices read as two problems.
+ */
+export function cspPlanProblem(sources, port) {
+    for (const source of sources) {
+        if ('string' !== typeof source)
+            continue;
+        const problem = cspConnectSrcProblem(source, port);
+        if (problem !== undefined)
+            return problem;
+    }
+    return undefined;
+}

package/dist/csp-doctor.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `doctor`'s web CSP check — the sibling of the desktop one next door.
+ *
+ * The desktop findings exist because a Tauri app with the default CSP runs perfectly and never
+ * connects. The WEB version of that failure had no check at all, and it arrived twice in one batch
+ * of field reports: two Next apps where `init` printed success for every step, the SDK mounted, the
+ * dial URL was right, and the browser silently refused the WebSocket because `connect-src` excluded
+ * the bridge. The violation is reported in the browser's console and nowhere else, so every check on
+ * this side stayed green while the app was permanently unreachable.
+ *
+ * Reads the files a CSP is actually written in, by name — a full source scan would be slower and
+ * would find policy strings in test fixtures and documentation.
+ */
+/** Read a project-relative file, or undefined when it is absent/unreadable. */
+type ReadFile = (relative: string) => string | undefined;
+interface CspDiagnosis {
+    /** Which file to look at. */
+    file: string;
+    /** What is wrong, in one line. */
+    problem: string;
+    /** Exactly what to add — copy-pasteable, with the port actually in use. */
+    fix: string;
+}
+/**
+ * The places a Content-Security-Policy gets written in a JS app.
+ *
+ * Next config and middleware cover `headers()` and the edge-middleware style; the layouts and the
+ * plain `index.html` cover the `<meta http-equiv>` style. Both reported cases were in this list.
+ */
+export declare const CSP_FILES: readonly string[];
+export declare function diagnoseWebCsp(read: ReadFile, port: number, alsoCheck?: readonly string[]): CspDiagnosis[];
+export {};

package/dist/csp-doctor.js

@@ -0,0 +1,62 @@
+/**
+ * `doctor`'s web CSP check — the sibling of the desktop one next door.
+ *
+ * The desktop findings exist because a Tauri app with the default CSP runs perfectly and never
+ * connects. The WEB version of that failure had no check at all, and it arrived twice in one batch
+ * of field reports: two Next apps where `init` printed success for every step, the SDK mounted, the
+ * dial URL was right, and the browser silently refused the WebSocket because `connect-src` excluded
+ * the bridge. The violation is reported in the browser's console and nowhere else, so every check on
+ * this side stayed green while the app was permanently unreachable.
+ *
+ * Reads the files a CSP is actually written in, by name — a full source scan would be slower and
+ * would find policy strings in test fixtures and documentation.
+ */
+import { cspConnectSrcProblem, cspInlineScriptProblem, devCspAddition, externalScriptRemedy, } from './csp-check.js';
+/**
+ * The places a Content-Security-Policy gets written in a JS app.
+ *
+ * Next config and middleware cover `headers()` and the edge-middleware style; the layouts and the
+ * plain `index.html` cover the `<meta http-equiv>` style. Both reported cases were in this list.
+ */
+export const CSP_FILES = [
+    'next.config.js',
+    'next.config.mjs',
+    'next.config.ts',
+    'middleware.ts',
+    'middleware.js',
+    'src/middleware.ts',
+    'app/layout.tsx',
+    'app/layout.js',
+    'pages/_document.tsx',
+    'pages/_document.js',
+    'index.html',
+    'public/index.html',
+    // Vite puts the entry HTML at the project root; electron-vite and Tauri put the RENDERER's one
+    // under src/. MarkText declares its policy in `src/renderer/index.html`, and a desktop app is the
+    // likeliest place to meet a strict CSP at all — Electron's own security guidance asks for one.
+    'src/index.html',
+    'src/renderer/index.html',
+    'vercel.json',
+    'netlify.toml',
+];
+export function diagnoseWebCsp(read, port, alsoCheck = []) {
+    const findings = [];
+    for (const file of [...alsoCheck, ...CSP_FILES]) {
+        const source = read(file);
+        if (source === undefined)
+            continue;
+        // `script-src` first, because it is the earlier failure. A policy that blocks the inline
+        // snippet means there is no SDK at all, so a `connect-src` finding on the same file would be
+        // describing a socket that is never opened -- true, and the wrong thing to fix first (#679).
+        const inline = cspInlineScriptProblem(source, port);
+        if (inline !== undefined) {
+            findings.push({ file, problem: inline, fix: externalScriptRemedy() });
+            continue;
+        }
+        const problem = cspConnectSrcProblem(source, port);
+        if (problem === undefined)
+            continue;
+        findings.push({ file, problem, fix: devCspAddition(port) });
+    }
+    return findings;
+}

package/dist/desktop-doctor.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Setup RCA for desktop apps.
+ *
+ * Every failure this catches is SILENT. A Tauri app with the default CSP runs perfectly and simply
+ * never appears in `reticle status` — the WebSocket is blocked before it opens, and nothing in the
+ * app's own console says so. An Electron app missing the preload line works fine and reports zero
+ * network activity forever, which reads as "the app makes no backend calls" rather than "you are
+ * blind to all of them".
+ *
+ * Silent misconfiguration is the same disease as a false green: the tool answers confidently and the
+ * answer is wrong. So the diagnosis names the file, the reason, and the exact line to add.
+ *
+ * Pure: a `read` function in, findings out. No fs, no cwd, no process.
+ */
+export declare const DesktopFinding: {
+    /** Tauri's CSP will block the bridge WebSocket — the app will never connect, with no error. */
+    readonly TAURI_CSP_BLOCKS_BRIDGE: "tauri-csp-blocks-bridge";
+    /** A custom CSP dropped the `ipc:` source Tauri needs for `invoke` itself. */
+    readonly TAURI_CSP_BLOCKS_IPC: "tauri-csp-blocks-ipc";
+    /** The preload never requires the shim, so every IPC call is invisible. */
+    readonly ELECTRON_PRELOAD_MISSING: "electron-preload-missing";
+    /** The main process never installs the capture helper, so screenshots are unavailable. */
+    readonly ELECTRON_CAPTURE_MISSING: "electron-capture-missing";
+};
+export type DesktopFinding = (typeof DesktopFinding)[keyof typeof DesktopFinding];
+export interface DesktopDiagnosis {
+    code: DesktopFinding;
+    /** Which file to look at. */
+    file: string;
+    /** What is wrong, in one line. */
+    problem: string;
+    /** Exactly what to add — copy-pasteable, with the port actually in use. */
+    fix: string;
+}
+/** Reads a project-relative path. Undefined means the file does not exist. */
+type ReadFile = (path: string) => string | undefined;
+export declare const PRELOAD_REQUIRE = "@reticlehq/electron/preload";
+export declare const CAPTURE_REQUIRE = "@reticlehq/electron/main";
+/** The copy-pasteable line `diagnoseDesktop` already prints; the main patcher reuses it on MANUAL. */
+export declare const ELECTRON_CAPTURE_FIX = "add:  const { installReticleCapture } = require('@reticlehq/electron/main')  then installReticleCapture(win)";
+export declare const ELECTRON_PRELOAD_FIX = "add as the FIRST line:  require('@reticlehq/electron/preload')";
+/** Is this project a desktop shell at all? Used to print a positive result instead of silence. */
+export declare function isDesktopProject(read: ReadFile): boolean;
+/** Which desktop shell (if any) this project is, and what is missing from its Reticle wiring. */
+export declare function diagnoseDesktop(read: ReadFile, port: number): DesktopDiagnosis[];
+export {};

package/dist/desktop-doctor.js

@@ -0,0 +1,201 @@
+import { RETICLE_IPC_GLOBAL } from '@reticlehq/core';
+/**
+ * Setup RCA for desktop apps.
+ *
+ * Every failure this catches is SILENT. A Tauri app with the default CSP runs perfectly and simply
+ * never appears in `reticle status` — the WebSocket is blocked before it opens, and nothing in the
+ * app's own console says so. An Electron app missing the preload line works fine and reports zero
+ * network activity forever, which reads as "the app makes no backend calls" rather than "you are
+ * blind to all of them".
+ *
+ * Silent misconfiguration is the same disease as a false green: the tool answers confidently and the
+ * answer is wrong. So the diagnosis names the file, the reason, and the exact line to add.
+ *
+ * Pure: a `read` function in, findings out. No fs, no cwd, no process.
+ */
+export const DesktopFinding = {
+    /** Tauri's CSP will block the bridge WebSocket — the app will never connect, with no error. */
+    TAURI_CSP_BLOCKS_BRIDGE: 'tauri-csp-blocks-bridge',
+    /** A custom CSP dropped the `ipc:` source Tauri needs for `invoke` itself. */
+    TAURI_CSP_BLOCKS_IPC: 'tauri-csp-blocks-ipc',
+    /** The preload never requires the shim, so every IPC call is invisible. */
+    ELECTRON_PRELOAD_MISSING: 'electron-preload-missing',
+    /** The main process never installs the capture helper, so screenshots are unavailable. */
+    ELECTRON_CAPTURE_MISSING: 'electron-capture-missing',
+};
+const TAURI_CONF = 'src-tauri/tauri.conf.json';
+export const PRELOAD_REQUIRE = '@reticlehq/electron/preload';
+export const CAPTURE_REQUIRE = '@reticlehq/electron/main';
+/** The copy-pasteable line `diagnoseDesktop` already prints; the main patcher reuses it on MANUAL. */
+export const ELECTRON_CAPTURE_FIX = `add:  const { installReticleCapture } = require('${CAPTURE_REQUIRE}')  then installReticleCapture(win)`;
+export const ELECTRON_PRELOAD_FIX = `add as the FIRST line:  require('${PRELOAD_REQUIRE}')`;
+function parseJson(text) {
+    if (text === undefined)
+        return undefined;
+    try {
+        const parsed = JSON.parse(text);
+        return 'object' === typeof parsed && parsed !== null
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined; // a malformed config is the app's problem, not something to crash the doctor on
+    }
+}
+function record(value) {
+    return 'object' === typeof value && value !== null ? value : {};
+}
+/**
+ * Does this CSP permit the bridge WebSocket on `port`?
+ *
+ * A MISSING csp key is treated as blocking, not permissive: Tauri applies a restrictive default, so
+ * reporting "no CSP, therefore fine" would be precisely the false green this tool exists to prevent.
+ */
+function cspAllowsBridge(csp, port) {
+    if (csp === undefined)
+        return false;
+    const exact = `ws://localhost:${String(port)}`;
+    const loopback = `ws://127.0.0.1:${String(port)}`;
+    // A BARE `ws:` scheme source allows any ws origin. It must be matched as a whole source, not as a
+    // substring: `includes('ws:')` also matches `ws://localhost:4400`, which would make every port
+    // look allowed and silently defeat the port check this function exists to perform.
+    const bareScheme = /(^|[\s;])ws:(?!\/\/)/.test(csp);
+    return (csp.includes(exact) ||
+        csp.includes(loopback) ||
+        csp.includes('ws://localhost:*') ||
+        csp.includes('ws://127.0.0.1:*') ||
+        bareScheme);
+}
+/** Tauri v2 needs `ipc:`/`http://ipc.localhost` in connect-src for `invoke` to work at all. */
+function cspAllowsIpc(csp) {
+    return csp.includes('ipc:') || csp.includes('ipc.localhost');
+}
+function diagnoseTauri(read, port) {
+    const conf = parseJson(read(TAURI_CONF));
+    if (conf === undefined)
+        return [];
+    const security = record(record(conf['app'])['security']);
+    const csp = 'string' === typeof security['csp'] ? security['csp'] : undefined;
+    const findings = [];
+    if (!cspAllowsBridge(csp, port)) {
+        findings.push({
+            code: DesktopFinding.TAURI_CSP_BLOCKS_BRIDGE,
+            file: TAURI_CONF,
+            problem: csp === undefined
+                ? "no `app.security.csp` set, so Tauri's restrictive default applies and blocks the Reticle bridge — the app will run normally and never connect"
+                : 'the CSP `connect-src` does not allow the Reticle bridge WebSocket — the app will run normally and never connect',
+            fix: `add to app.security.csp connect-src:  ws://localhost:${String(port)}`,
+        });
+    }
+    if (csp !== undefined && !cspAllowsIpc(csp)) {
+        findings.push({
+            code: DesktopFinding.TAURI_CSP_BLOCKS_IPC,
+            file: TAURI_CONF,
+            problem: 'the CSP dropped the `ipc:` source Tauri needs — `invoke` itself will fail',
+            fix: 'add to app.security.csp connect-src:  ipc: http://ipc.localhost',
+        });
+    }
+    return findings;
+}
+/** The directory portion of a path, without pulling in node:path (this module stays pure). */
+function dirOf(path) {
+    const cut = path.lastIndexOf('/');
+    return cut < 0 ? '' : path.slice(0, cut + 1);
+}
+/**
+ * Where a preload SOURCE might live, in the order worth trying.
+ *
+ * Beside `main` first (the unbundled layout), then the usual source directories — a bundled setup
+ * points `main` at `out/` or `dist/` while the real preload stays in `src/` or `electron/`.
+ */
+function preloadCandidates(mainDir) {
+    const names = ['preload.cjs', 'preload.js', 'preload.mjs', 'preload.ts', 'preload.mts'];
+    const dirs = [mainDir, 'electron/', 'src/', 'src/preload/', 'src/main/', ''];
+    return dirs.flatMap((dir) => names.map((name) => `${dir}${name}`));
+}
+/**
+ * Where a BUNDLED preload's output lands. electron-vite's default layout mirrors `out/main` with
+ * `out/preload`; Forge and hand-rolled setups favour `dist`/`build`.
+ */
+function bundledPreloadCandidates(mainDir) {
+    const roots = [mainDir.replace(/main\/?$/, ''), 'out/', 'dist/', 'build/', '.vite/build/'];
+    const names = [
+        'preload/index.js',
+        'preload/index.mjs',
+        'preload/index.cjs',
+        'preload.js',
+        'preload.mjs',
+        'preload.cjs',
+    ];
+    return roots.flatMap((root) => names.map((name) => `${root}${name}`));
+}
+/**
+ * Is the preload wired, judged from whatever evidence exists?
+ *
+ * Source first (the require is right there). Failing that, the BUILD OUTPUT: bundling inlines the
+ * shim, and the shim carries the contract's own window global — finding that string in the artifact
+ * proves the preload is wired even though the require has been compiled away. Undefined means no
+ * evidence either way, and an unknown must never be reported as a fault.
+ */
+function preloadWired(read, mainDir) {
+    for (const candidate of preloadCandidates(mainDir)) {
+        const source = read(candidate);
+        if (source !== undefined)
+            return { wired: source.includes(PRELOAD_REQUIRE), file: candidate };
+    }
+    for (const candidate of bundledPreloadCandidates(mainDir)) {
+        const built = read(candidate);
+        if (built !== undefined) {
+            return { wired: built.includes(RETICLE_IPC_GLOBAL), file: candidate };
+        }
+    }
+    return undefined;
+}
+function diagnoseElectron(read, main) {
+    const findings = [];
+    const dir = dirOf(main);
+    // Undefined = no source AND no build output to judge from. An unknown is not a fault.
+    const preload = preloadWired(read, dir);
+    if (preload !== undefined && !preload.wired) {
+        findings.push({
+            code: DesktopFinding.ELECTRON_PRELOAD_MISSING,
+            file: preload.file,
+            problem: 'the preload never installs the Reticle IPC shim, so every ipcRenderer.invoke is invisible — reticle_network will report nothing and read as "this app makes no backend calls"',
+            fix: ELECTRON_PRELOAD_FIX,
+        });
+    }
+    const mainSource = read(main);
+    if (mainSource !== undefined && !mainSource.includes(CAPTURE_REQUIRE)) {
+        findings.push({
+            code: DesktopFinding.ELECTRON_CAPTURE_MISSING,
+            file: main,
+            problem: 'the main process never installs the capture helper, so screenshots are unavailable',
+            fix: ELECTRON_CAPTURE_FIX,
+        });
+    }
+    return findings;
+}
+/** Is this project a desktop shell at all? Used to print a positive result instead of silence. */
+export function isDesktopProject(read) {
+    if (read(TAURI_CONF) !== undefined)
+        return true;
+    const pkg = parseJson(read('package.json'));
+    if (pkg === undefined)
+        return false;
+    const deps = { ...record(pkg['dependencies']), ...record(pkg['devDependencies']) };
+    return deps['electron'] !== undefined;
+}
+/** Which desktop shell (if any) this project is, and what is missing from its Reticle wiring. */
+export function diagnoseDesktop(read, port) {
+    const tauri = diagnoseTauri(read, port);
+    if (tauri.length > 0 || read(TAURI_CONF) !== undefined)
+        return tauri;
+    const pkg = parseJson(read('package.json'));
+    if (pkg === undefined)
+        return [];
+    const deps = { ...record(pkg['dependencies']), ...record(pkg['devDependencies']) };
+    if (deps['electron'] === undefined)
+        return [];
+    const main = 'string' === typeof pkg['main'] ? pkg['main'] : undefined;
+    return main === undefined ? [] : diagnoseElectron(read, main);
+}