@agentrhq/webcmd 0.1.1 → 0.2.0

package/dist/src/download/media-download.js

@@ -0,0 +1,127 @@
+/**
+ * Media download helper — shared logic for batch downloading images/videos.
+ *
+ * Used by: twitter/download, youtube/download,
+ * and future media adapters.
+ *
+ * Flow: MediaItem[] → DownloadProgressTracker → httpDownload/ytdlpDownload → results
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getErrorMessage } from '../errors.js';
+import { httpDownload, ytdlpDownload, checkYtdlp, getTempDir, exportCookiesToNetscape, sanitizeFilename, } from './index.js';
+import { DownloadProgressTracker, formatBytes } from './progress.js';
+// ============================================================
+// Main API
+// ============================================================
+/**
+ * Batch download media files with progress tracking.
+ *
+ * Handles:
+ * - DownloadProgressTracker for terminal UX
+ * - Automatic httpDownload vs ytdlpDownload routing via MediaItem.type
+ * - Cookie export to Netscape format for yt-dlp (auto-cleanup)
+ * - Directory creation
+ * - Error handling with per-file results
+ */
+export async function downloadMedia(items, options) {
+    const { output, subdir, cookies, browserCookies, timeout, filenamePrefix = 'download', ytdlpExtraArgs = [], verbose = true, } = options;
+    if (!items || items.length === 0) {
+        return [{ index: 0, type: '-', status: 'failed', size: 'No media found' }];
+    }
+    // Create output directory
+    const outputDir = subdir ? path.join(output, subdir) : output;
+    fs.mkdirSync(outputDir, { recursive: true });
+    // Pre-check yt-dlp availability (once, not per-item)
+    const hasYtdlp = checkYtdlp();
+    // Auto-export browser cookies to Netscape format for yt-dlp
+    let cookiesFile;
+    const needsYtdlp = items.some(m => m.type === 'video-tweet' || m.type === 'video-ytdlp');
+    if (needsYtdlp && browserCookies && browserCookies.length > 0) {
+        const tempDir = getTempDir();
+        fs.mkdirSync(tempDir, { recursive: true });
+        cookiesFile = path.join(tempDir, `media_cookies_${Date.now()}.txt`);
+        exportCookiesToNetscape(browserCookies, cookiesFile);
+    }
+    const tracker = new DownloadProgressTracker(items.length, verbose);
+    const results = [];
+    try {
+        for (let i = 0; i < items.length; i++) {
+            const media = items[i];
+            const isVideo = media.type !== 'image';
+            const ext = isVideo ? 'mp4' : 'jpg';
+            const filename = resolveMediaFilename(media.filename, filenamePrefix, i + 1, ext);
+            const destPath = path.join(outputDir, filename);
+            const progressBar = tracker.onFileStart(filename, i);
+            try {
+                let result;
+                const useYtdlp = (media.type === 'video-tweet' || media.type === 'video-ytdlp') && hasYtdlp;
+                if (useYtdlp) {
+                    result = await ytdlpDownload(media.url, destPath, {
+                        cookiesFile,
+                        extraArgs: ytdlpExtraArgs,
+                        onProgress: (percent) => {
+                            if (progressBar)
+                                progressBar.update(percent, 100);
+                        },
+                    });
+                }
+                else {
+                    // Direct HTTP download for images and direct video URLs
+                    const dlTimeout = timeout || (isVideo ? 60000 : 30000);
+                    result = await httpDownload(media.url, destPath, {
+                        cookies,
+                        timeout: dlTimeout,
+                        onProgress: (received, total) => {
+                            if (progressBar)
+                                progressBar.update(received, total);
+                        },
+                    });
+                }
+                if (progressBar) {
+                    progressBar.complete(result.success, result.success ? formatBytes(result.size) : undefined);
+                }
+                tracker.onFileComplete(result.success);
+                results.push({
+                    index: i + 1,
+                    type: media.type === 'video-tweet' || media.type === 'video-ytdlp' ? 'video' : media.type,
+                    status: result.success ? 'success' : 'failed',
+                    size: result.success ? formatBytes(result.size) : (result.error || 'unknown error'),
+                });
+            }
+            catch (err) {
+                const msg = getErrorMessage(err);
+                if (progressBar)
+                    progressBar.fail(msg);
+                tracker.onFileComplete(false);
+                results.push({
+                    index: i + 1,
+                    type: media.type,
+                    status: 'failed',
+                    size: msg,
+                });
+            }
+        }
+    }
+    finally {
+        tracker.finish();
+        // Auto-cleanup exported cookies file
+        if (cookiesFile && fs.existsSync(cookiesFile)) {
+            fs.unlinkSync(cookiesFile);
+        }
+    }
+    return results;
+}
+function resolveMediaFilename(filename, prefix, index, ext) {
+    const safePrefix = sanitizePathSegment(path.basename(path.win32.basename(prefix))) || 'download';
+    const fallback = `${safePrefix}_${index}.${ext}`;
+    if (!filename)
+        return fallback;
+    const basename = path.basename(path.win32.basename(filename));
+    const safeName = sanitizePathSegment(basename);
+    return safeName || fallback;
+}
+function sanitizePathSegment(value) {
+    const sanitized = sanitizeFilename(value);
+    return sanitized && sanitized !== '.' && sanitized !== '..' ? sanitized : '';
+}

package/dist/src/download/media-download.test.d.ts

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

package/dist/src/download/media-download.test.js

@@ -0,0 +1,112 @@
+import * as fs from 'node:fs';
+import * as http from 'node:http';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { downloadMedia } from './media-download.js';
+const servers = [];
+const tempDirs = [];
+afterEach(async () => {
+    await Promise.all(servers.map((server) => new Promise((resolve, reject) => {
+        server.close((err) => (err ? reject(err) : resolve()));
+    })));
+    servers.length = 0;
+    for (const dir of tempDirs) {
+        try {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    }
+    tempDirs.length = 0;
+});
+async function startServer(handler) {
+    const server = http.createServer(handler);
+    servers.push(server);
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Failed to start test server');
+    }
+    return `http://127.0.0.1:${address.port}`;
+}
+// Windows runners occasionally exceed the default 5s timeout on the first
+// http.createServer + downloadMedia roundtrip (cold-start cost on a loaded VM).
+describe('media downloads', { retry: process.platform === 'win32' ? 2 : 0 }, () => {
+    it('keeps custom filenames inside the output directory', async () => {
+        const baseUrl = await startServer((_req, res) => {
+            res.statusCode = 200;
+            res.end('image');
+        });
+        const parentDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'webcmd-media-parent-'));
+        tempDirs.push(parentDir);
+        const outputDir = path.join(parentDir, 'downloads');
+        const results = await downloadMedia([
+            { type: 'image', url: `${baseUrl}/image.jpg`, filename: '../escape.jpg' },
+        ], {
+            output: outputDir,
+            verbose: false,
+        });
+        expect(results).toEqual([
+            { index: 1, type: 'image', status: 'success', size: '5.0 B' },
+        ]);
+        expect(fs.readFileSync(path.join(outputDir, 'escape.jpg'), 'utf8')).toBe('image');
+        expect(fs.existsSync(path.join(parentDir, 'escape.jpg'))).toBe(false);
+    });
+    it('strips nested and absolute path components from custom filenames', async () => {
+        const baseUrl = await startServer((_req, res) => {
+            res.statusCode = 200;
+            res.end('image');
+        });
+        const parentDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'webcmd-media-parent-'));
+        tempDirs.push(parentDir);
+        const outputDir = path.join(parentDir, 'downloads');
+        const results = await downloadMedia([
+            { type: 'image', url: `${baseUrl}/one.jpg`, filename: '../../etc/passwd' },
+            { type: 'image', url: `${baseUrl}/two.jpg`, filename: '/tmp/evil.jpg' },
+            { type: 'image', url: `${baseUrl}/three.jpg`, filename: 'nested/path/photo.png' },
+            { type: 'image', url: `${baseUrl}/four.jpg`, filename: '..\\windows\\escape.jpg' },
+        ], {
+            output: outputDir,
+            verbose: false,
+        });
+        expect(results).toEqual([
+            { index: 1, type: 'image', status: 'success', size: '5.0 B' },
+            { index: 2, type: 'image', status: 'success', size: '5.0 B' },
+            { index: 3, type: 'image', status: 'success', size: '5.0 B' },
+            { index: 4, type: 'image', status: 'success', size: '5.0 B' },
+        ]);
+        expect(fs.readFileSync(path.join(outputDir, 'passwd'), 'utf8')).toBe('image');
+        expect(fs.readFileSync(path.join(outputDir, 'evil.jpg'), 'utf8')).toBe('image');
+        expect(fs.readFileSync(path.join(outputDir, 'photo.png'), 'utf8')).toBe('image');
+        expect(fs.readFileSync(path.join(outputDir, 'escape.jpg'), 'utf8')).toBe('image');
+        expect(fs.existsSync(path.join(parentDir, 'etc', 'passwd'))).toBe(false);
+        expect(fs.existsSync(path.join(parentDir, 'tmp', 'evil.jpg'))).toBe(false);
+    });
+    it('falls back to generated names for empty dot-directory filenames', async () => {
+        const baseUrl = await startServer((_req, res) => {
+            res.statusCode = 200;
+            res.end('image');
+        });
+        const parentDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'webcmd-media-parent-'));
+        tempDirs.push(parentDir);
+        const outputDir = path.join(parentDir, 'downloads');
+        const results = await downloadMedia([
+            { type: 'image', url: `${baseUrl}/dot.jpg`, filename: '.' },
+            { type: 'image', url: `${baseUrl}/dotdot.jpg`, filename: '..' },
+            { type: 'image', url: `${baseUrl}/blank.jpg`, filename: '   ' },
+        ], {
+            output: outputDir,
+            filenamePrefix: '../unsafe prefix',
+            verbose: false,
+        });
+        expect(results).toEqual([
+            { index: 1, type: 'image', status: 'success', size: '5.0 B' },
+            { index: 2, type: 'image', status: 'success', size: '5.0 B' },
+            { index: 3, type: 'image', status: 'success', size: '5.0 B' },
+        ]);
+        expect(fs.readFileSync(path.join(outputDir, 'unsafe_prefix_1.jpg'), 'utf8')).toBe('image');
+        expect(fs.readFileSync(path.join(outputDir, 'unsafe_prefix_2.jpg'), 'utf8')).toBe('image');
+        expect(fs.readFileSync(path.join(outputDir, 'unsafe_prefix_3.jpg'), 'utf8')).toBe('image');
+        expect(fs.existsSync(path.join(parentDir, 'unsafe prefix_1.jpg'))).toBe(false);
+    });
+});

package/dist/src/download/progress.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Download progress display: terminal progress bars, status updates.
+ */
+export interface ProgressBar {
+    update(current: number, total: number, label?: string): void;
+    complete(success: boolean, message?: string): void;
+    fail(error: string): void;
+}
+/**
+ * Format bytes as human-readable string (KB, MB, GB).
+ */
+export declare function formatBytes(bytes: number): string;
+/**
+ * Format milliseconds as human-readable duration.
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * Create a simple progress bar for terminal display.
+ */
+export declare function createProgressBar(filename: string, index: number, total: number): ProgressBar;
+/**
+ * Multi-file download progress tracker.
+ */
+export declare class DownloadProgressTracker {
+    private completed;
+    private failed;
+    private skipped;
+    private total;
+    private startTime;
+    private verbose;
+    constructor(total: number, verbose?: boolean);
+    onFileStart(filename: string, index: number): ProgressBar | null;
+    onFileComplete(success: boolean, skipped?: boolean): void;
+    getSummary(): string;
+    finish(): void;
+}

package/dist/src/download/progress.js

@@ -0,0 +1,120 @@
+/**
+ * Download progress display: terminal progress bars, status updates.
+ */
+/**
+ * Format bytes as human-readable string (KB, MB, GB).
+ */
+export function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes < 1)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.min(sizes.length - 1, Math.floor(Math.log(bytes) / Math.log(k)));
+    return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+}
+/**
+ * Format milliseconds as human-readable duration.
+ */
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60) {
+        const remainingSeconds = seconds % 60;
+        return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+}
+/**
+ * Create a simple progress bar for terminal display.
+ */
+export function createProgressBar(filename, index, total) {
+    const prefix = `[${index + 1}/${total}]`;
+    const truncatedName = filename.length > 40 ? filename.slice(0, 37) + '...' : filename;
+    return {
+        update(current, totalBytes, label) {
+            const percent = clampPercent(totalBytes > 0 ? Math.round((current / totalBytes) * 100) : 0);
+            const bar = createBar(percent);
+            const size = totalBytes > 0 ? formatBytes(totalBytes) : '';
+            const extra = label ? ` ${label}` : '';
+            process.stderr.write(`\r${prefix} ${truncatedName} ${bar} ${percent}% ${size}${extra}`);
+        },
+        complete(success, message) {
+            const icon = success ? '✓' : '✗';
+            const msg = message ? ` ${message}` : '';
+            process.stderr.write(`\r${prefix} ${icon} ${truncatedName}${msg}\n`);
+        },
+        fail(error) {
+            process.stderr.write(`\r${prefix} ✗ ${truncatedName} ${error}\n`);
+        },
+    };
+}
+function clampPercent(percent) {
+    if (!Number.isFinite(percent))
+        return 0;
+    return Math.max(0, Math.min(100, percent));
+}
+/**
+ * Create a progress bar string.
+ */
+function createBar(percent, width = 20) {
+    const filled = Math.round((percent / 100) * width);
+    const empty = width - filled;
+    return '█'.repeat(filled) + '░'.repeat(empty);
+}
+/**
+ * Multi-file download progress tracker.
+ */
+export class DownloadProgressTracker {
+    completed = 0;
+    failed = 0;
+    skipped = 0;
+    total;
+    startTime;
+    verbose;
+    constructor(total, verbose = true) {
+        this.total = total;
+        this.startTime = Date.now();
+        this.verbose = verbose;
+    }
+    onFileStart(filename, index) {
+        if (!this.verbose)
+            return null;
+        return createProgressBar(filename, index, this.total);
+    }
+    onFileComplete(success, skipped = false) {
+        if (skipped) {
+            this.skipped++;
+        }
+        else if (success) {
+            this.completed++;
+        }
+        else {
+            this.failed++;
+        }
+    }
+    getSummary() {
+        const elapsed = formatDuration(Date.now() - this.startTime);
+        const parts = [];
+        if (this.completed > 0) {
+            parts.push(`${this.completed} downloaded`);
+        }
+        if (this.skipped > 0) {
+            parts.push(`${this.skipped} skipped`);
+        }
+        if (this.failed > 0) {
+            parts.push(`${this.failed} failed`);
+        }
+        return `${parts.join(', ')} in ${elapsed}`;
+    }
+    finish() {
+        if (this.verbose) {
+            process.stderr.write(`\nDownload complete: ${this.getSummary()}\n`);
+        }
+    }
+}

package/dist/src/download/progress.test.d.ts

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

package/dist/src/download/progress.test.js

@@ -0,0 +1,36 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createProgressBar, formatBytes } from './progress.js';
+describe('formatBytes', () => {
+    it('returns a stable zero-byte label for invalid or sub-byte values', () => {
+        expect(formatBytes(-1)).toBe('0 B');
+        expect(formatBytes(0.5)).toBe('0 B');
+        expect(formatBytes(Number.NaN)).toBe('0 B');
+        expect(formatBytes(Number.POSITIVE_INFINITY)).toBe('0 B');
+    });
+    it('caps very large values at the largest supported unit', () => {
+        expect(formatBytes(1024 ** 5)).toBe('1024.0 TB');
+    });
+});
+describe('download progress display', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('clamps percentages above 100 to keep the progress bar renderable', () => {
+        const write = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        const progress = createProgressBar('file.bin', 0, 1);
+        expect(() => progress.update(150, 100)).not.toThrow();
+        expect(write).toHaveBeenCalledWith(expect.stringContaining('100%'));
+    });
+    it('clamps negative percentages to zero', () => {
+        const write = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        const progress = createProgressBar('file.bin', 0, 1);
+        expect(() => progress.update(-10, 100)).not.toThrow();
+        expect(write).toHaveBeenCalledWith(expect.stringContaining('0%'));
+    });
+    it('renders zero percent when the total size is unknown', () => {
+        const write = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        const progress = createProgressBar('file.bin', 0, 1);
+        expect(() => progress.update(50, 0)).not.toThrow();
+        expect(write).toHaveBeenCalledWith(expect.stringContaining('0%'));
+    });
+});

package/dist/src/electron-apps.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Electron app registry — maps site names to launch metadata.
+ *
+ * Builtin apps are defined here. User-defined apps are loaded
+ * from ~/.webcmd/apps.yaml (additive only, does not override builtins).
+ */
+export interface ElectronAppEntry {
+    /** CDP debug port (unique per app) */
+    port: number;
+    /** macOS process name for detection via pgrep */
+    processName: string;
+    /** Candidate executable names inside Contents/MacOS/, tried in order */
+    executableNames?: string[];
+    /** macOS bundle ID for path discovery */
+    bundleId?: string;
+    /** Human-readable name for prompts */
+    displayName?: string;
+    /** Additional launch args beyond --remote-debugging-port */
+    extraArgs?: string[];
+}
+export declare const builtinApps: Record<string, ElectronAppEntry>;
+/** Merge builtin + user-defined apps. User entries are additive only. */
+export declare function loadApps(userApps?: Record<string, Omit<ElectronAppEntry, 'displayName'> & {
+    displayName?: string;
+}>): Record<string, ElectronAppEntry>;
+export declare function getElectronApp(site: string): ElectronAppEntry | undefined;
+export declare function isElectronApp(site: string): boolean;
+/** Get all registered apps (builtin + user-defined). */
+export declare function getAllElectronApps(): Record<string, ElectronAppEntry>;
+/** Reset loaded apps (for testing). */
+export declare function _resetRegistry(): void;

package/dist/src/electron-apps.js

@@ -0,0 +1,83 @@
+/**
+ * Electron app registry — maps site names to launch metadata.
+ *
+ * Builtin apps are defined here. User-defined apps are loaded
+ * from ~/.webcmd/apps.yaml (additive only, does not override builtins).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import yaml from 'js-yaml';
+export const builtinApps = {
+    cursor: { port: 9226, processName: 'Cursor', bundleId: 'com.todesktop.runtime.Cursor', displayName: 'Cursor' },
+    codex: { port: 9238, processName: 'Codex', bundleId: 'com.openai.codex', displayName: 'Codex' },
+    chatwise: { port: 9228, processName: 'ChatWise', bundleId: 'com.chatwise.app', displayName: 'ChatWise' },
+    'discord-app': { port: 9232, processName: 'Discord', bundleId: 'com.discord.app', displayName: 'Discord' },
+    antigravity: {
+        port: 9234,
+        processName: 'Antigravity',
+        executableNames: ['Electron', 'Antigravity'],
+        bundleId: 'dev.antigravity.app',
+        displayName: 'Antigravity',
+    },
+    'chatgpt-app': { port: 9236, processName: 'ChatGPT', bundleId: 'com.openai.chat', displayName: 'ChatGPT' },
+    qoder: {
+        port: 9237,
+        processName: 'Qoder',
+        executableNames: ['Electron'],
+        bundleId: 'com.qoder.ide',
+        displayName: 'Qoder',
+    },
+    'trae-solo': {
+        port: 9235,
+        processName: 'TRAE SOLO',
+        executableNames: ['Electron', 'TRAE SOLO'],
+        bundleId: 'com.trae.solo.app',
+        displayName: 'Trae SOLO',
+    },
+};
+/** Merge builtin + user-defined apps. User entries are additive only. */
+export function loadApps(userApps) {
+    const merged = { ...builtinApps };
+    if (userApps) {
+        for (const [name, entry] of Object.entries(userApps)) {
+            if (!(name in merged)) {
+                merged[name] = entry;
+            }
+        }
+    }
+    return merged;
+}
+let _apps = null;
+function ensureLoaded() {
+    if (_apps)
+        return _apps;
+    let userApps;
+    try {
+        const yamlPath = path.join(os.homedir(), '.webcmd', 'apps.yaml');
+        if (fs.existsSync(yamlPath)) {
+            const content = fs.readFileSync(yamlPath, 'utf-8');
+            const parsed = yaml.load(content);
+            userApps = parsed?.apps;
+        }
+    }
+    catch {
+        // Silently ignore malformed user config
+    }
+    _apps = loadApps(userApps);
+    return _apps;
+}
+export function getElectronApp(site) {
+    return ensureLoaded()[site];
+}
+export function isElectronApp(site) {
+    return site in ensureLoaded();
+}
+/** Get all registered apps (builtin + user-defined). */
+export function getAllElectronApps() {
+    return ensureLoaded();
+}
+/** Reset loaded apps (for testing). */
+export function _resetRegistry() {
+    _apps = null;
+}

package/dist/src/electron-apps.test.d.ts

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

package/dist/src/electron-apps.test.js

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest';
+import { builtinApps, getElectronApp, isElectronApp, loadApps } from './electron-apps.js';
+describe('electron-apps registry', () => {
+    it('returns builtin app entry for cursor', () => {
+        const app = getElectronApp('cursor');
+        expect(app).toBeDefined();
+        expect(app.port).toBe(9226);
+        expect(app.processName).toBe('Cursor');
+    });
+    it('returns builtin app entry for codex', () => {
+        const app = getElectronApp('codex');
+        expect(app).toBeDefined();
+        expect(app.port).toBe(9238);
+    });
+    it('keeps builtin Electron app CDP ports unique and off the browser-bridge port', () => {
+        const ports = Object.values(builtinApps).map((app) => app.port);
+        expect(new Set(ports).size).toBe(ports.length);
+        expect(ports).not.toContain(9222);
+    });
+    it('returns undefined for non-Electron sites', () => {
+        expect(getElectronApp('youtube')).toBeUndefined();
+        expect(getElectronApp('hackernews')).toBeUndefined();
+    });
+    it('isElectronApp returns true for registered apps', () => {
+        expect(isElectronApp('cursor')).toBe(true);
+        expect(isElectronApp('codex')).toBe(true);
+        expect(isElectronApp('chatwise')).toBe(true);
+        expect(isElectronApp('qoder')).toBe(true);
+        expect(isElectronApp('trae-solo')).toBe(true);
+    });
+    it('registers Qoder on its own CDP port', () => {
+        const app = getElectronApp('qoder');
+        expect(app).toMatchObject({
+            port: 9237,
+            processName: 'Qoder',
+            bundleId: 'com.qoder.ide',
+            displayName: 'Qoder',
+        });
+    });
+    it('registers Trae SOLO with its own CDP port and process metadata', () => {
+        const app = getElectronApp('trae-solo');
+        expect(app).toBeDefined();
+        expect(app.port).toBe(9235);
+        expect(app.processName).toBe('TRAE SOLO');
+        expect(app.bundleId).toBe('com.trae.solo.app');
+    });
+    it('isElectronApp returns false for non-Electron sites', () => {
+        expect(isElectronApp('youtube')).toBe(false);
+        expect(isElectronApp('notion')).toBe(false);
+        expect(isElectronApp('unknown-app')).toBe(false);
+    });
+    it('loadApps merges user config additively', () => {
+        const apps = loadApps({
+            myapp: { port: 9234, processName: 'MyApp' },
+        });
+        expect(apps.myapp).toBeDefined();
+        expect(apps.myapp.port).toBe(9234);
+        // Builtins still present
+        expect(apps.cursor).toBeDefined();
+    });
+    it('loadApps does not override builtin entries', () => {
+        const apps = loadApps({
+            cursor: { port: 9999, processName: 'FakeCursor' },
+        });
+        expect(apps.cursor.port).toBe(9226); // Builtin wins
+    });
+});

package/dist/src/engine.test.d.ts

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