sliccy 0.1.0

package/dist/cli/electron-controller.js

@@ -0,0 +1,287 @@
+import { execFile as nodeExecFile, spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { promisify } from 'util';
+import { WebSocket } from 'ws';
+import { buildElectronAppLaunchSpec, buildElectronOverlayAppUrl, buildElectronOverlayBootstrapScript, buildElectronOverlayEntryUrl, getElectronOverlayEntryDistPath, getElectronServeOrigin, shouldInjectElectronOverlayTarget, } from './electron-runtime.js';
+const execFile = promisify(nodeExecFile);
+const ELECTRON_OVERLAY_SYNC_INTERVAL_MS = 1500;
+function commandLineExecutableMatchesPattern(commandLine, pattern) {
+    // Extract the executable (first whitespace-separated token) from the command line.
+    // Only match when the target app path is the executable itself, not an argument —
+    // this avoids false positives when the path appears as a CLI flag (e.g. --kill /App.app).
+    const executable = commandLine.trimStart().split(/\s+/)[0] ?? '';
+    return executable === pattern
+        || executable.startsWith(pattern + '/')
+        || executable.startsWith(pattern + '\\');
+}
+export function findMatchingElectronAppPids(runningProcesses, processMatchPatterns, currentPid = process.pid) {
+    const matches = runningProcesses.filter((processInfo) => {
+        // Skip Node.js tool-chain processes and shell wrappers — they may have the app path
+        // as a CLI argument but are not the Electron app itself
+        // (e.g. npx tsx src/cli/index.ts --electron /Applications/Slack.app)
+        // Shell wrappers like `zsh -c ... /Applications/Slack.app --kill` or
+        // `timeout 30 npm run dev:electron -- /Applications/Slack.app` also match.
+        const cmdTrimmed = processInfo.commandLine.trimStart();
+        if (/^(\/\S*\/)?(node|npx|tsx|npm|open|bash|zsh|sh|csh|fish|dash|timeout|env|sudo|caffeinate)\b/i.test(cmdTrimmed))
+            return false;
+        return processMatchPatterns.some((pattern) => {
+            return commandLineExecutableMatchesPattern(processInfo.commandLine, pattern)
+                || (processInfo.executablePath?.includes(pattern) ?? false);
+        });
+    });
+    return Array.from(new Set(matches.map((processInfo) => processInfo.pid).filter((pid) => pid !== currentPid)));
+}
+export class ElectronAppAlreadyRunningError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ElectronAppAlreadyRunningError';
+    }
+}
+function parseUnixProcessList(stdout) {
+    const processes = [];
+    for (const rawLine of stdout.split('\n')) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const match = line.match(/^(\d+)\s+(.*)$/);
+        if (!match)
+            continue;
+        const pid = Number.parseInt(match[1] ?? '', 10);
+        if (!Number.isFinite(pid) || pid <= 0)
+            continue;
+        processes.push({
+            pid,
+            commandLine: match[2] ?? '',
+            executablePath: null,
+        });
+    }
+    return processes;
+}
+function parseWindowsProcessList(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed)
+        return [];
+    const parsed = JSON.parse(trimmed);
+    const entries = Array.isArray(parsed) ? parsed : [parsed];
+    return entries
+        .map((entry) => ({
+        pid: Number.parseInt(String(entry['ProcessId'] ?? ''), 10),
+        commandLine: String(entry['CommandLine'] ?? ''),
+        executablePath: entry['ExecutablePath'] == null ? null : String(entry['ExecutablePath']),
+    }))
+        .filter((processInfo) => Number.isFinite(processInfo.pid) && processInfo.pid > 0);
+}
+async function listRunningProcesses(platform = process.platform) {
+    if (platform === 'win32') {
+        const { stdout } = await execFile('powershell', [
+            '-NoProfile',
+            '-Command',
+            'Get-CimInstance Win32_Process | Select-Object ProcessId, ExecutablePath, CommandLine | ConvertTo-Json -Compress',
+        ]);
+        return parseWindowsProcessList(stdout);
+    }
+    const { stdout } = await execFile('ps', ['-ax', '-o', 'pid=', '-o', 'command=']);
+    return parseUnixProcessList(stdout);
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForPidsToExit(pids, timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (pids.every((pid) => !isPidAlive(pid)))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return pids.every((pid) => !isPidAlive(pid));
+}
+async function terminateRunningApp(pids) {
+    for (const pid of pids) {
+        if (!isPidAlive(pid))
+            continue;
+        try {
+            process.kill(pid);
+        }
+        catch {
+            // Ignore individual termination failures and fall back to force-kill below if needed.
+        }
+    }
+    if (await waitForPidsToExit(pids))
+        return;
+    for (const pid of pids) {
+        if (!isPidAlive(pid))
+            continue;
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch {
+            // Ignore final cleanup failures.
+        }
+    }
+    await waitForPidsToExit(pids, 3000);
+}
+async function findRunningElectronAppPids(appPath, platform = process.platform) {
+    const { processMatchPatterns } = buildElectronAppLaunchSpec(appPath, { cdpPort: 0, platform });
+    const runningProcesses = await listRunningProcesses(platform);
+    return findMatchingElectronAppPids(runningProcesses, processMatchPatterns);
+}
+export async function launchElectronApp(options) {
+    const launchSpec = buildElectronAppLaunchSpec(options.appPath, {
+        cdpPort: options.cdpPort,
+        platform: options.platform,
+    });
+    if (!existsSync(launchSpec.resolvedAppPath)) {
+        throw new Error(`Electron app not found at ${launchSpec.resolvedAppPath}`);
+    }
+    if (!existsSync(launchSpec.command)) {
+        throw new Error(`Electron executable not found at ${launchSpec.command}. Pass the app executable path directly if needed.`);
+    }
+    const runningPids = await findRunningElectronAppPids(launchSpec.resolvedAppPath, options.platform);
+    const platform = options.platform ?? process.platform;
+    const isMacAppBundle = platform === 'darwin' && launchSpec.resolvedAppPath.toLowerCase().endsWith('.app');
+    if (runningPids.length > 0 && !options.kill) {
+        throw new ElectronAppAlreadyRunningError(`${launchSpec.displayName} is already running. Re-run with --kill to relaunch it with remote debugging enabled.`);
+    }
+    if (runningPids.length > 0) {
+        await terminateRunningApp(runningPids);
+    }
+    const child = isMacAppBundle
+        ? spawn('open', ['-n', '-a', launchSpec.resolvedAppPath, '-W', '--args', ...launchSpec.args], {
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            detached: false,
+        })
+        : spawn(launchSpec.command, launchSpec.args, {
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            detached: false,
+        });
+    return {
+        child,
+        displayName: launchSpec.displayName,
+    };
+}
+async function loadElectronOverlayBundleSource(options) {
+    const serveOrigin = getElectronServeOrigin(options.servePort);
+    if (options.dev) {
+        const response = await fetch(buildElectronOverlayEntryUrl(serveOrigin));
+        if (!response.ok) {
+            throw new Error(`Failed to fetch electron overlay entry: ${response.status} ${response.statusText}`);
+        }
+        return await response.text();
+    }
+    return await readFile(getElectronOverlayEntryDistPath(options.projectRoot), 'utf8');
+}
+export class ElectronOverlayInjector {
+    cdpPort;
+    bootstrapScript;
+    connections = new Map();
+    syncTimer = null;
+    syncing = false;
+    constructor(cdpPort, bootstrapScript) {
+        this.cdpPort = cdpPort;
+        this.bootstrapScript = bootstrapScript;
+    }
+    static async create(options) {
+        const bundleSource = await loadElectronOverlayBundleSource(options);
+        const bootstrapScript = buildElectronOverlayBootstrapScript({
+            bundleSource,
+            appUrl: buildElectronOverlayAppUrl(getElectronServeOrigin(options.servePort)),
+        });
+        return new ElectronOverlayInjector(options.cdpPort, bootstrapScript);
+    }
+    async start() {
+        await this.syncTargets();
+        this.syncTimer = setInterval(() => {
+            void this.syncTargets();
+        }, ELECTRON_OVERLAY_SYNC_INTERVAL_MS);
+    }
+    stop() {
+        if (this.syncTimer) {
+            clearInterval(this.syncTimer);
+            this.syncTimer = null;
+        }
+        for (const connection of this.connections.values()) {
+            try {
+                connection.close();
+            }
+            catch {
+                // Ignore connection cleanup failures.
+            }
+        }
+        this.connections.clear();
+    }
+    async syncTargets() {
+        if (this.syncing)
+            return;
+        this.syncing = true;
+        try {
+            const response = await fetch(`http://127.0.0.1:${this.cdpPort}/json/list`);
+            if (!response.ok) {
+                throw new Error(`CDP target listing failed with ${response.status} ${response.statusText}`);
+            }
+            const targets = (await response.json());
+            const injectableTargets = targets.filter(shouldInjectElectronOverlayTarget);
+            const liveConnectionIds = new Set(injectableTargets.map((target) => target.webSocketDebuggerUrl));
+            for (const [targetId, connection] of this.connections.entries()) {
+                if (liveConnectionIds.has(targetId))
+                    continue;
+                try {
+                    connection.close();
+                }
+                catch {
+                    // Ignore stale connection cleanup failures.
+                }
+                this.connections.delete(targetId);
+            }
+            for (const target of injectableTargets) {
+                const targetId = target.webSocketDebuggerUrl;
+                if (this.connections.has(targetId))
+                    continue;
+                this.connectToTarget(target);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error('[electron-float] Overlay sync failed:', message);
+        }
+        finally {
+            this.syncing = false;
+        }
+    }
+    connectToTarget(target) {
+        const targetId = target.webSocketDebuggerUrl;
+        const ws = new WebSocket(targetId);
+        this.connections.set(targetId, ws);
+        let messageId = 1;
+        const send = (method, params) => {
+            ws.send(JSON.stringify({ id: messageId++, method, params }));
+        };
+        ws.on('open', () => {
+            send('Page.enable');
+            send('Runtime.enable');
+            send('Page.addScriptToEvaluateOnNewDocument', { source: this.bootstrapScript });
+            send('Runtime.evaluate', { expression: this.bootstrapScript, awaitPromise: false });
+            console.log(`[electron-float] Overlay injector attached to ${target.url}`);
+        });
+        ws.on('close', () => {
+            if (this.connections.get(targetId) === ws) {
+                this.connections.delete(targetId);
+            }
+        });
+        ws.on('error', (error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`[electron-float] Overlay target connection failed for ${target.url}:`, message);
+            if (this.connections.get(targetId) === ws) {
+                this.connections.delete(targetId);
+            }
+        });
+    }
+}

package/dist/cli/electron-main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/electron-main.js

@@ -0,0 +1,183 @@
+import { spawn } from 'child_process';
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { app, BrowserWindow, session } from 'electron';
+import { buildElectronOverlayAppUrl, buildElectronOverlayEntryUrl, buildElectronOverlayInjectionCall, buildElectronServerSpawnConfig, getElectronOverlayEntryDistPath, getElectronServeOrigin, parseElectronFloatFlags, } from './electron-runtime.js';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const PROJECT_ROOT = resolve(__dirname, '..', '..');
+const FLAGS = parseElectronFloatFlags(process.argv.slice(2));
+const SERVE_ORIGIN = getElectronServeOrigin(FLAGS.servePort);
+const OVERLAY_APP_URL = buildElectronOverlayAppUrl(SERVE_ORIGIN);
+const ELECTRON_PARTITION = 'persist:slicc-electron-float';
+app.commandLine.appendSwitch('remote-debugging-port', String(FLAGS.cdpPort));
+let cliServerProcess = null;
+let quitting = false;
+function pipeChildOutput(child, label) {
+    child.stdout?.on('data', (data) => {
+        process.stdout.write(`[${label}:out] ${data}`);
+    });
+    child.stderr?.on('data', (data) => {
+        process.stderr.write(`[${label}:err] ${data}`);
+    });
+}
+async function waitForServerReady(origin, retries = 60, delayMs = 500) {
+    for (let i = 0; i < retries; i += 1) {
+        try {
+            const response = await fetch(origin);
+            if (response.ok || response.status < 500)
+                return;
+        }
+        catch {
+            // Retry until the server starts listening.
+        }
+        await new Promise((resolvePromise) => setTimeout(resolvePromise, delayMs));
+    }
+    throw new Error(`Electron float server did not become ready at ${origin}`);
+}
+async function loadOverlayBundleSource() {
+    if (FLAGS.dev) {
+        const response = await fetch(buildElectronOverlayEntryUrl(SERVE_ORIGIN));
+        if (!response.ok) {
+            throw new Error(`Failed to fetch electron overlay entry: ${response.status} ${response.statusText}`);
+        }
+        return await response.text();
+    }
+    return await readFile(getElectronOverlayEntryDistPath(PROJECT_ROOT), 'utf8');
+}
+async function injectOverlay(window) {
+    const bundleSource = await loadOverlayBundleSource();
+    await window.webContents.executeJavaScript(bundleSource, true);
+    await window.webContents.executeJavaScript(buildElectronOverlayInjectionCall({ appUrl: OVERLAY_APP_URL }), true);
+}
+function wireOverlayReinjection(window) {
+    const reinject = () => {
+        void injectOverlay(window).catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error('[electron-float] Overlay injection failed:', message);
+        });
+    };
+    window.webContents.on('did-finish-load', reinject);
+    window.webContents.on('did-navigate-in-page', reinject);
+}
+function configureElectronSession() {
+    const electronSession = session.fromPartition(ELECTRON_PARTITION);
+    electronSession.webRequest.onHeadersReceived((details, callback) => {
+        const responseHeaders = { ...(details.responseHeaders ?? {}) };
+        delete responseHeaders['content-security-policy'];
+        delete responseHeaders['Content-Security-Policy'];
+        delete responseHeaders['content-security-policy-report-only'];
+        delete responseHeaders['Content-Security-Policy-Report-Only'];
+        callback({ responseHeaders });
+    });
+}
+async function createFloatWindow(targetUrl) {
+    const window = new BrowserWindow({
+        width: 1440,
+        height: 960,
+        minWidth: 1024,
+        minHeight: 720,
+        autoHideMenuBar: true,
+        title: 'slicc electron float',
+        webPreferences: {
+            partition: ELECTRON_PARTITION,
+            contextIsolation: true,
+            nodeIntegration: false,
+            sandbox: true,
+            allowRunningInsecureContent: true,
+        },
+    });
+    wireOverlayReinjection(window);
+    window.webContents.setWindowOpenHandler(({ url }) => {
+        void createFloatWindow(url);
+        return { action: 'deny' };
+    });
+    try {
+        await window.loadURL(targetUrl);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[electron-float] Failed to load ${targetUrl}: ${message}`);
+        await window.loadURL('about:blank');
+    }
+    return window;
+}
+function startCliServer() {
+    const spawnConfig = buildElectronServerSpawnConfig(PROJECT_ROOT, {
+        dev: FLAGS.dev,
+        cdpPort: FLAGS.cdpPort,
+        nodePath: process.env['npm_node_execpath'] ?? 'node',
+    });
+    const child = spawn(spawnConfig.command, spawnConfig.args, {
+        cwd: PROJECT_ROOT,
+        env: {
+            ...process.env,
+            PORT: String(FLAGS.servePort),
+        },
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    pipeChildOutput(child, 'electron-server');
+    child.on('exit', (code) => {
+        if (quitting)
+            return;
+        console.error(`[electron-float] CLI server exited unexpectedly with code ${code}`);
+        app.quit();
+    });
+    return child;
+}
+async function stopCliServer() {
+    if (!cliServerProcess)
+        return;
+    const child = cliServerProcess;
+    cliServerProcess = null;
+    await new Promise((resolvePromise) => {
+        let resolved = false;
+        const finish = () => {
+            if (resolved)
+                return;
+            resolved = true;
+            resolvePromise();
+        };
+        child.once('exit', finish);
+        child.kill('SIGTERM');
+        setTimeout(() => {
+            if (child.exitCode === null) {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch {
+                    // Ignore final cleanup failures.
+                }
+            }
+            finish();
+        }, 3000);
+    });
+}
+async function main() {
+    await app.whenReady();
+    configureElectronSession();
+    cliServerProcess = startCliServer();
+    await waitForServerReady(SERVE_ORIGIN);
+    await createFloatWindow(FLAGS.targetUrl);
+    app.on('activate', () => {
+        if (BrowserWindow.getAllWindows().length === 0) {
+            void createFloatWindow(FLAGS.targetUrl);
+        }
+    });
+}
+app.on('before-quit', () => {
+    quitting = true;
+});
+app.on('window-all-closed', () => {
+    app.quit();
+});
+app.on('will-quit', () => {
+    void stopCliServer();
+});
+main().catch((error) => {
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    console.error('[electron-float] Fatal error:', message);
+    void stopCliServer().finally(() => {
+        app.exit(1);
+    });
+});

package/dist/cli/electron-runtime.d.ts

@@ -0,0 +1,58 @@
+export interface ElectronFloatFlags {
+    dev: boolean;
+    cdpPort: number;
+    servePort: number;
+    targetUrl: string;
+}
+export interface ElectronServerSpawnConfig {
+    command: string;
+    args: string[];
+}
+export interface ElectronAppLaunchSpec {
+    command: string;
+    args: string[];
+    displayName: string;
+    resolvedAppPath: string;
+    processMatchPatterns: string[];
+}
+export interface ElectronInspectableTarget {
+    type: string;
+    url: string;
+    webSocketDebuggerUrl?: string;
+}
+export declare const DEFAULT_ELECTRON_SERVE_PORT = 5710;
+export declare const DEFAULT_ELECTRON_SERVE_HOST = "localhost";
+export declare const DEFAULT_ELECTRON_CDP_PORT = 9223;
+export declare const DEFAULT_ELECTRON_TARGET_URL = "about:blank";
+export declare const DEFAULT_ELECTRON_OVERLAY_TAB = "chat";
+export declare const ELECTRON_OVERLAY_APP_PATH = "/electron";
+export declare function getElectronAppDisplayName(appPath: string): string;
+export declare function resolveElectronAppExecutablePath(appPath: string, platform?: NodeJS.Platform): string;
+export declare function buildElectronAppProcessMatchPatterns(appPath: string, platform?: NodeJS.Platform): string[];
+export declare function buildElectronAppLaunchSpec(appPath: string, options: {
+    cdpPort: number;
+    platform?: NodeJS.Platform;
+}): ElectronAppLaunchSpec;
+export declare function parseElectronFloatFlags(argv: string[], env?: Record<string, string | undefined>): ElectronFloatFlags;
+export declare function buildElectronServerSpawnConfig(projectRoot: string, options: {
+    dev: boolean;
+    cdpPort: number;
+    platform?: NodeJS.Platform;
+    nodePath?: string;
+}): ElectronServerSpawnConfig;
+export declare function getElectronServeOrigin(servePort: number): string;
+export declare function buildElectronOverlayAppUrl(serveOrigin: string, activeTab?: string): string;
+export declare function buildElectronOverlayEntryUrl(serveOrigin: string): string;
+export declare function getElectronOverlayEntryDistPath(projectRoot: string): string;
+export declare function buildElectronOverlayInjectionCall(options: {
+    appUrl: string;
+    open?: boolean;
+    activeTab?: string;
+}): string;
+export declare function buildElectronOverlayBootstrapScript(options: {
+    bundleSource: string;
+    appUrl: string;
+    open?: boolean;
+    activeTab?: string;
+}): string;
+export declare function shouldInjectElectronOverlayTarget(target: ElectronInspectableTarget): boolean;

package/dist/cli/electron-runtime.js

@@ -0,0 +1,133 @@
+import { basename, join, resolve } from 'path';
+export const DEFAULT_ELECTRON_SERVE_PORT = 5710;
+export const DEFAULT_ELECTRON_SERVE_HOST = 'localhost';
+export const DEFAULT_ELECTRON_CDP_PORT = 9223;
+export const DEFAULT_ELECTRON_TARGET_URL = 'about:blank';
+export const DEFAULT_ELECTRON_OVERLAY_TAB = 'chat';
+export const ELECTRON_OVERLAY_APP_PATH = '/electron';
+export function getElectronAppDisplayName(appPath) {
+    const trimmedPath = appPath.replace(/[\\/]+$/, '');
+    const fileName = basename(trimmedPath);
+    if (fileName.toLowerCase().endsWith('.app')) {
+        return fileName.slice(0, -'.app'.length) || fileName;
+    }
+    return fileName || trimmedPath;
+}
+export function resolveElectronAppExecutablePath(appPath, platform = process.platform) {
+    const resolvedAppPath = resolve(appPath);
+    if (platform === 'darwin' && resolvedAppPath.toLowerCase().endsWith('.app')) {
+        return join(resolvedAppPath, 'Contents', 'MacOS', getElectronAppDisplayName(resolvedAppPath));
+    }
+    return resolvedAppPath;
+}
+export function buildElectronAppProcessMatchPatterns(appPath, platform = process.platform) {
+    return Array.from(new Set([
+        resolve(appPath),
+        resolveElectronAppExecutablePath(appPath, platform),
+    ]));
+}
+export function buildElectronAppLaunchSpec(appPath, options) {
+    const platform = options.platform ?? process.platform;
+    const resolvedAppPath = resolve(appPath);
+    const displayName = getElectronAppDisplayName(resolvedAppPath);
+    const executablePath = resolveElectronAppExecutablePath(resolvedAppPath, platform);
+    return {
+        command: executablePath,
+        args: [`--remote-debugging-port=${options.cdpPort}`],
+        displayName,
+        resolvedAppPath,
+        processMatchPatterns: buildElectronAppProcessMatchPatterns(resolvedAppPath, platform),
+    };
+}
+function parsePositiveInt(value, fallback) {
+    if (!value)
+        return fallback;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+export function parseElectronFloatFlags(argv, env = process.env) {
+    let dev = false;
+    let cdpPort = DEFAULT_ELECTRON_CDP_PORT;
+    let targetUrl = DEFAULT_ELECTRON_TARGET_URL;
+    for (const arg of argv) {
+        if (arg === '--dev') {
+            dev = true;
+            continue;
+        }
+        if (arg.startsWith('--cdp-port=')) {
+            cdpPort = parsePositiveInt(arg.slice('--cdp-port='.length), DEFAULT_ELECTRON_CDP_PORT);
+            continue;
+        }
+        if (arg.startsWith('--target-url=')) {
+            const value = arg.slice('--target-url='.length).trim();
+            targetUrl = value || DEFAULT_ELECTRON_TARGET_URL;
+            continue;
+        }
+        if (!arg.startsWith('--')) {
+            targetUrl = arg.trim() || DEFAULT_ELECTRON_TARGET_URL;
+        }
+    }
+    return {
+        dev,
+        cdpPort,
+        servePort: parsePositiveInt(env['PORT'], DEFAULT_ELECTRON_SERVE_PORT),
+        targetUrl,
+    };
+}
+export function buildElectronServerSpawnConfig(projectRoot, options) {
+    if (options.dev) {
+        return {
+            command: (options.platform ?? process.platform) === 'win32' ? 'npx.cmd' : 'npx',
+            args: ['tsx', 'src/cli/index.ts', '--dev', '--serve-only', `--cdp-port=${options.cdpPort}`],
+        };
+    }
+    return {
+        command: options.nodePath ?? process.env['npm_node_execpath'] ?? 'node',
+        args: [resolve(projectRoot, 'dist/cli/index.js'), '--serve-only', `--cdp-port=${options.cdpPort}`],
+    };
+}
+export function getElectronServeOrigin(servePort) {
+    return `http://${DEFAULT_ELECTRON_SERVE_HOST}:${servePort}`;
+}
+export function buildElectronOverlayAppUrl(serveOrigin, activeTab = DEFAULT_ELECTRON_OVERLAY_TAB) {
+    const url = new URL(ELECTRON_OVERLAY_APP_PATH, serveOrigin);
+    if (activeTab && activeTab !== DEFAULT_ELECTRON_OVERLAY_TAB) {
+        url.searchParams.set('tab', activeTab);
+    }
+    return url.toString();
+}
+export function buildElectronOverlayEntryUrl(serveOrigin) {
+    return new URL('/electron-overlay-entry.js', serveOrigin).toString();
+}
+export function getElectronOverlayEntryDistPath(projectRoot) {
+    return resolve(projectRoot, 'dist/ui/electron-overlay-entry.js');
+}
+export function buildElectronOverlayInjectionCall(options) {
+    const payload = {
+        appUrl: options.appUrl,
+    };
+    if (typeof options.open === 'boolean') {
+        payload['open'] = options.open;
+    }
+    if (options.activeTab) {
+        payload['activeTab'] = options.activeTab;
+    }
+    return `window.__SLICC_ELECTRON_OVERLAY__?.inject(${JSON.stringify(payload)});`;
+}
+export function buildElectronOverlayBootstrapScript(options) {
+    return `${options.bundleSource}\n${buildElectronOverlayInjectionCall(options)}`;
+}
+export function shouldInjectElectronOverlayTarget(target) {
+    if (target.type !== 'page' || !target.webSocketDebuggerUrl)
+        return false;
+    const url = target.url.trim();
+    if (!url)
+        return false;
+    if (url.startsWith('devtools://'))
+        return false;
+    if (url.startsWith('chrome://'))
+        return false;
+    if (url.startsWith('chrome-extension://'))
+        return false;
+    return true;
+}