sliccy 0.1.0

package/dist/cli/chrome-launch.js

@@ -0,0 +1,324 @@
+import { existsSync, readdirSync } from 'fs';
+import { mkdir, readFile, writeFile } from 'fs/promises';
+import { homedir } from 'os';
+import { dirname, join } from 'path';
+export const CLI_PROFILE_NAMES = ['leader', 'follower', 'extension'];
+const DEFAULT_USER_DATA_DIR_NAME = 'browser-coding-agent-chrome';
+const QA_PROFILE_ROOT_SEGMENTS = ['.qa', 'chrome'];
+function argbToSignedInt(argbHex) {
+    return argbHex | 0;
+}
+const CLI_PROFILE_DEFINITIONS = {
+    leader: {
+        displayName: 'SLICC QA Leader',
+        avatarIndex: 0,
+        avatarIcon: 'chrome://theme/IDR_PROFILE_AVATAR_0',
+        profileColorSeed: argbToSignedInt(0xff4285f4),
+        profileHighlightColor: argbToSignedInt(0xff4285f4),
+        loadsExtension: false,
+    },
+    follower: {
+        displayName: 'SLICC QA Follower',
+        avatarIndex: 7,
+        avatarIcon: 'chrome://theme/IDR_PROFILE_AVATAR_7',
+        profileColorSeed: argbToSignedInt(0xff34a853),
+        profileHighlightColor: argbToSignedInt(0xff34a853),
+        loadsExtension: false,
+    },
+    extension: {
+        displayName: 'SLICC QA Extension',
+        avatarIndex: 19,
+        avatarIcon: 'chrome://theme/IDR_PROFILE_AVATAR_19',
+        profileColorSeed: argbToSignedInt(0xffa142f4),
+        profileHighlightColor: argbToSignedInt(0xffa142f4),
+        loadsExtension: true,
+    },
+};
+function isJsonObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function ensureObject(parent, key) {
+    const existing = parent[key];
+    if (isJsonObject(existing))
+        return existing;
+    const next = {};
+    parent[key] = next;
+    return next;
+}
+function normalizeProfileName(profile) {
+    const trimmed = profile?.trim();
+    return trimmed ? trimmed : null;
+}
+export function isCliProfileName(value) {
+    return CLI_PROFILE_NAMES.includes(value ?? '');
+}
+export function resolveQaProfilesRoot(projectRoot) {
+    return join(projectRoot, ...QA_PROFILE_ROOT_SEGMENTS);
+}
+export function resolveDefaultChromeUserDataDir(tmpDir = process.env['TMPDIR'] ?? '/tmp') {
+    return join(tmpDir, DEFAULT_USER_DATA_DIR_NAME);
+}
+export function resolveChromeLaunchProfile(options) {
+    const profile = normalizeProfileName(options.profile);
+    if (!profile) {
+        return {
+            id: null,
+            displayName: 'Chrome',
+            userDataDir: resolveDefaultChromeUserDataDir(options.tmpDir ?? undefined),
+            extensionPath: null,
+        };
+    }
+    if (!isCliProfileName(profile)) {
+        throw new Error(`Unknown Chrome profile "${profile}". Supported values: ${CLI_PROFILE_NAMES.join(', ')}.`);
+    }
+    const definition = CLI_PROFILE_DEFINITIONS[profile];
+    return {
+        id: profile,
+        displayName: definition.displayName,
+        userDataDir: join(resolveQaProfilesRoot(options.projectRoot), profile),
+        extensionPath: definition.loadsExtension ? join(options.projectRoot, 'dist', 'extension') : null,
+    };
+}
+export function buildChromeLaunchArgs(options) {
+    const args = [
+        `--remote-debugging-port=${options.cdpPort}`,
+        '--no-first-run',
+        '--no-default-browser-check',
+        `--user-data-dir=${options.profile.userDataDir}`,
+    ];
+    if (options.profile.extensionPath) {
+        args.push(`--disable-extensions-except=${options.profile.extensionPath}`);
+        args.push(`--load-extension=${options.profile.extensionPath}`);
+    }
+    args.push(options.launchUrl);
+    return args;
+}
+function findPuppeteerChromeForTesting(options) {
+    const cacheRoot = join(options.homeDir, '.cache', 'puppeteer', 'chrome');
+    let entries;
+    try {
+        entries = options.readdirSyncImpl(cacheRoot);
+    }
+    catch {
+        return null;
+    }
+    const prefix = options.platform === 'darwin'
+        ? /^mac/i
+        : options.platform === 'linux'
+            ? /^linux/i
+            : options.platform === 'win32'
+                ? /^win/i
+                : null;
+    if (!prefix)
+        return null;
+    const executableSuffixes = options.platform === 'darwin'
+        ? [
+            join('chrome-mac-arm64', 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing'),
+            join('chrome-mac-x64', 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing'),
+        ]
+        : options.platform === 'linux'
+            ? [join('chrome-linux64', 'chrome'), join('chrome-linux', 'chrome')]
+            : [join('chrome-win64', 'chrome.exe'), join('chrome-win32', 'chrome.exe')];
+    const sortedEntries = entries
+        .filter((entry) => prefix.test(entry))
+        .sort((left, right) => right.localeCompare(left, undefined, { numeric: true }));
+    for (const entry of sortedEntries) {
+        for (const suffix of executableSuffixes) {
+            const candidate = join(cacheRoot, entry, suffix);
+            if (options.existsSyncImpl(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * On macOS, if a path points to a `.app` bundle, resolve it to the inner
+ * `Contents/MacOS/<name>` executable. Returns `null` if the path is not a
+ * `.app` bundle or the inner executable does not exist.
+ */
+function resolveMacAppBundle(appPath, platform, existsSyncImpl) {
+    if (platform !== 'darwin' || !appPath.endsWith('.app'))
+        return null;
+    // Derive the binary name from the bundle name:
+    // "Google Chrome.app" → "Google Chrome"
+    const bundleName = appPath.split('/').pop().replace(/\.app$/, '');
+    const candidate = join(appPath, 'Contents', 'MacOS', bundleName);
+    return existsSyncImpl(candidate) ? candidate : null;
+}
+function findInstalledChrome(options) {
+    const candidates = {
+        darwin: [
+            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+            '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+            '/Applications/Chromium.app/Contents/MacOS/Chromium',
+        ],
+        linux: [
+            '/usr/bin/google-chrome',
+            '/usr/bin/google-chrome-stable',
+            '/usr/bin/chromium',
+            '/usr/bin/chromium-browser',
+            '/snap/bin/chromium',
+        ],
+        win32: [
+            `${options.env['LOCALAPPDATA']}\\Google\\Chrome\\Application\\chrome.exe`,
+            `${options.env['PROGRAMFILES']}\\Google\\Chrome\\Application\\chrome.exe`,
+            `${options.env['PROGRAMFILES(X86)']}\\Google\\Chrome\\Application\\chrome.exe`,
+        ],
+    };
+    for (const candidate of candidates[options.platform] ?? []) {
+        if (candidate && options.existsSyncImpl(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export function findChromeExecutable(options = {}) {
+    const env = options.env ?? process.env;
+    const existsSyncImpl = options.existsSyncImpl ?? existsSync;
+    const readdirSyncImpl = options.readdirSyncImpl ?? readdirSync;
+    const platform = options.platform ?? process.platform;
+    const homeDir = options.homeDir ?? homedir();
+    const executablePreference = options.executablePreference ?? 'chrome-for-testing';
+    const envPath = env['CHROME_PATH'];
+    if (envPath && existsSyncImpl(envPath)) {
+        const resolved = resolveMacAppBundle(envPath, platform, existsSyncImpl);
+        return resolved ?? envPath;
+    }
+    const installedChrome = findInstalledChrome({
+        env,
+        platform,
+        existsSyncImpl,
+    });
+    const chromeForTesting = findPuppeteerChromeForTesting({
+        platform,
+        homeDir,
+        existsSyncImpl,
+        readdirSyncImpl,
+    });
+    return executablePreference === 'installed'
+        ? installedChrome ?? chromeForTesting
+        : chromeForTesting ?? installedChrome;
+}
+async function readJsonFile(filePath) {
+    try {
+        const raw = await readFile(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return isJsonObject(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+async function writeJsonFile(filePath, value) {
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+function seedLocalState(localState, definition) {
+    const browser = ensureObject(localState, 'browser');
+    browser['check_default_browser'] = false;
+    browser['has_seen_welcome_page'] = true;
+    const profile = ensureObject(localState, 'profile');
+    profile['last_used'] = 'Default';
+    profile['picker_shown'] = true;
+    profile['profiles_order'] = ['Default'];
+    profile['last_active_profiles'] = ['Default'];
+    const infoCache = ensureObject(profile, 'info_cache');
+    const defaultProfile = ensureObject(infoCache, 'Default');
+    defaultProfile['name'] = definition.displayName;
+    defaultProfile['avatar_icon'] = definition.avatarIcon;
+    defaultProfile['is_using_default_name'] = false;
+    defaultProfile['is_using_default_avatar'] = true;
+    defaultProfile['profile_color_seed'] = definition.profileColorSeed;
+    defaultProfile['profile_highlight_color'] = definition.profileHighlightColor;
+    return localState;
+}
+function seedPreferences(preferences, definition) {
+    const profile = ensureObject(preferences, 'profile');
+    profile['name'] = definition.displayName;
+    profile['avatar_index'] = definition.avatarIndex;
+    profile['using_default_name'] = false;
+    profile['using_default_avatar'] = true;
+    const browser = ensureObject(preferences, 'browser');
+    browser['has_seen_welcome_page'] = true;
+    const bookmarkBar = ensureObject(preferences, 'bookmark_bar');
+    bookmarkBar['show_on_all_tabs'] = false;
+    const signin = ensureObject(preferences, 'signin');
+    signin['allowed'] = false;
+    return preferences;
+}
+export async function ensureQaProfileScaffold(projectRoot) {
+    const profiles = CLI_PROFILE_NAMES.map((profileName) => resolveChromeLaunchProfile({ projectRoot, profile: profileName }));
+    for (const profile of profiles) {
+        const definition = CLI_PROFILE_DEFINITIONS[profile.id];
+        await mkdir(join(profile.userDataDir, 'Default'), { recursive: true });
+        await writeFile(join(profile.userDataDir, 'First Run'), '', 'utf8');
+        const localStatePath = join(profile.userDataDir, 'Local State');
+        const preferencesPath = join(profile.userDataDir, 'Default', 'Preferences');
+        const localState = seedLocalState(await readJsonFile(localStatePath), definition);
+        const preferences = seedPreferences(await readJsonFile(preferencesPath), definition);
+        await writeJsonFile(localStatePath, localState);
+        await writeJsonFile(preferencesPath, preferences);
+    }
+    return profiles;
+}
+// ---------------------------------------------------------------------------
+// CDP port parsing — extract actual port from Chrome's stderr output
+// ---------------------------------------------------------------------------
+/**
+ * Parse the CDP port from a Chrome stderr line.
+ * Chrome prints `DevTools listening on ws://HOST:PORT/devtools/browser/ID`
+ * to stderr when it starts. Returns the port number, or null if the line
+ * doesn't match.
+ */
+export function parseCdpPortFromStderr(line) {
+    const match = line.match(/DevTools listening on ws:\/\/[^:]+:(\d+)\//);
+    if (!match)
+        return null;
+    const port = Number.parseInt(match[1], 10);
+    return Number.isFinite(port) && port > 0 ? port : null;
+}
+/**
+ * Watch a Chrome child process's stderr for the `DevTools listening on` line
+ * and resolve with the actual CDP port. Rejects after `timeoutMs` if the line
+ * never appears (e.g. Chrome failed to start).
+ */
+export function waitForCdpPortFromStderr(child, timeoutMs = 15000) {
+    return new Promise((resolve, reject) => {
+        if (!child.stderr) {
+            reject(new Error('Chrome process has no stderr stream'));
+            return;
+        }
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                reject(new Error(`Timed out waiting for Chrome CDP port (${timeoutMs}ms)`));
+            }
+        }, timeoutMs);
+        const onData = (chunk) => {
+            if (settled)
+                return;
+            const text = chunk.toString('utf-8');
+            // stderr may deliver multiple lines in one chunk
+            for (const line of text.split('\n')) {
+                const port = parseCdpPortFromStderr(line);
+                if (port !== null) {
+                    settled = true;
+                    clearTimeout(timer);
+                    child.stderr.off('data', onData);
+                    resolve(port);
+                    return;
+                }
+            }
+        };
+        child.stderr.on('data', onData);
+        child.on('exit', (code) => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                reject(new Error(`Chrome exited with code ${code} before reporting CDP port`));
+            }
+        });
+    });
+}

package/dist/cli/cli-log-dedup.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Lightweight log deduplication for CLI-side console output.
+ *
+ * Fingerprints messages by replacing variable parts (numbers, IDs, hex, JSON blobs)
+ * with placeholders, then suppresses duplicates within a sliding window.
+ * Periodically flushes suppression counts so the operator knows what was hidden.
+ */
+export declare class CliLogDedup {
+    private entries;
+    private prefix;
+    constructor(prefix?: string);
+    /**
+     * Returns true if the message should be printed, false if suppressed.
+     * Automatically flushes stale entries and emits suppression summaries.
+     */
+    shouldLog(message: string): boolean;
+    private evict;
+    private flushEntry;
+}

package/dist/cli/cli-log-dedup.js

@@ -0,0 +1,62 @@
+/**
+ * Lightweight log deduplication for CLI-side console output.
+ *
+ * Fingerprints messages by replacing variable parts (numbers, IDs, hex, JSON blobs)
+ * with placeholders, then suppresses duplicates within a sliding window.
+ * Periodically flushes suppression counts so the operator knows what was hidden.
+ */
+const BUFFER_SIZE = 10;
+const WINDOW_MS = 60_000; // 1 minute
+function makeFingerprint(message) {
+    return message
+        // UUIDs
+        .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '<id>')
+        // Hex strings (8+ chars, e.g. session IDs, target IDs)
+        .replace(/\b[0-9A-Fa-f]{8,}\b/g, '<hex>')
+        // JSON object/array blobs — collapse {...} and [...]
+        .replace(/\{[^}]{20,}\}/g, '{…}')
+        .replace(/\[[^\]]{20,}\]/g, '[…]')
+        // Numbers (integers and floats)
+        .replace(/\b\d+(\.\d+)?\b/g, '<n>');
+}
+export class CliLogDedup {
+    entries = [];
+    prefix;
+    constructor(prefix = '[cdp-proxy]') {
+        this.prefix = prefix;
+    }
+    /**
+     * Returns true if the message should be printed, false if suppressed.
+     * Automatically flushes stale entries and emits suppression summaries.
+     */
+    shouldLog(message) {
+        const fp = makeFingerprint(message);
+        const now = Date.now();
+        // Evict stale entries
+        this.evict(now);
+        // Check for existing match
+        const existing = this.entries.find(e => e.fingerprint === fp);
+        if (existing) {
+            existing.count++;
+            return false;
+        }
+        // New entry — evict oldest if buffer full
+        if (this.entries.length >= BUFFER_SIZE) {
+            const evicted = this.entries.shift();
+            this.flushEntry(evicted);
+        }
+        this.entries.push({ fingerprint: fp, count: 0, firstSeen: now, sample: message.slice(0, 120) });
+        return true;
+    }
+    evict(now) {
+        while (this.entries.length > 0 && now - this.entries[0].firstSeen > WINDOW_MS) {
+            const evicted = this.entries.shift();
+            this.flushEntry(evicted);
+        }
+    }
+    flushEntry(entry) {
+        if (entry.count > 0) {
+            console.log(`${this.prefix} (suppressed ${entry.count} similar: "${entry.sample}")`);
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+import { type ChildProcess } from 'child_process';
+interface RunningProcessInfo {
+    pid: number;
+    commandLine: string;
+    executablePath: string | null;
+}
+export declare function findMatchingElectronAppPids(runningProcesses: RunningProcessInfo[], processMatchPatterns: string[], currentPid?: number): number[];
+export declare class ElectronAppAlreadyRunningError extends Error {
+    constructor(message: string);
+}
+export declare function launchElectronApp(options: {
+    appPath: string;
+    cdpPort: number;
+    kill: boolean;
+    platform?: NodeJS.Platform;
+}): Promise<{
+    child: ChildProcess;
+    displayName: string;
+}>;
+export declare class ElectronOverlayInjector {
+    private readonly cdpPort;
+    private readonly bootstrapScript;
+    private readonly connections;
+    private syncTimer;
+    private syncing;
+    private constructor();
+    static create(options: {
+        cdpPort: number;
+        servePort: number;
+        dev: boolean;
+        projectRoot: string;
+    }): Promise<ElectronOverlayInjector>;
+    start(): Promise<void>;
+    stop(): void;
+    private syncTargets;
+    private connectToTarget;
+}
+export {};