janissary 0.5.0

package/dist/browser/command.js

@@ -0,0 +1,104 @@
+// Parser for the `browser` command plus the two helpers the ACP tool loop needs
+// (`extractBrowserCommand` / `BROWSER_PRIMER`), mirroring `parseConnectionCommand`
+// (src/connections.ts) and the `db` equivalents in src/db.ts. Pure — no I/O. The host
+// (src/cli.tsx) performs the actual Playwright actions against the tab's browser.
+const USAGE = 'Usage: browser <open [name] [--headed]|list|use <id>|goto <url>|eval <js>|shot|content|close [id]|window close <id>>';
+// First-position subcommand keywords, exported for tab completion.
+export const BROWSER_SUBCOMMANDS = [
+    'open',
+    'list',
+    'use',
+    'goto',
+    'eval',
+    'shot',
+    'content',
+    'close',
+    'window',
+];
+/** Parse a `browser ...` command. Pure — performs no I/O. */
+export function parseBrowserCommand(input) {
+    const rest = input.trim().replace(/^browser\b\s*/i, '').trim();
+    if (!rest)
+        return { error: USAGE };
+    const [actionRaw, ...tail] = rest.split(/\s+/);
+    const action = actionRaw.toLowerCase();
+    // The argument text after the action verb, with original spacing preserved.
+    const argument = rest.slice(actionRaw.length).trim();
+    switch (action) {
+        case 'open': {
+            const tokens = tail;
+            const isHeaded = tokens.some((t) => t === '--headed' || t === '-H');
+            const name = tokens.find((t) => !t.startsWith('-'));
+            return { action: 'open', name, headed: isHeaded };
+        }
+        case 'list': {
+            return { action: 'list' };
+        }
+        case 'use': {
+            if (!tail[0])
+                return { error: 'Usage: browser use <id>' };
+            return { action: 'use', id: tail[0] };
+        }
+        case 'goto': {
+            if (!argument)
+                return { error: 'Usage: browser goto <url>' };
+            return { action: 'goto', url: argument };
+        }
+        case 'eval': {
+            if (!argument)
+                return { error: 'Usage: browser eval <js>' };
+            return { action: 'eval', js: argument };
+        }
+        case 'shot': {
+            return { action: 'shot' };
+        }
+        case 'content': {
+            return { action: 'content' };
+        }
+        case 'close': {
+            // `browser close <id>` is an alias for `browser window close <id>`; bare
+            // `browser close` closes the current window.
+            if (tail[0])
+                return { action: 'closeWindow', id: tail[0] };
+            return { action: 'close' };
+        }
+        case 'window': {
+            if (tail[0]?.toLowerCase() !== 'close' || !tail[1]) {
+                return { error: 'Usage: browser window close <id>' };
+            }
+            return { action: 'closeWindow', id: tail[1] };
+        }
+        default: {
+            return { error: USAGE };
+        }
+    }
+}
+/**
+ * Pull a proposed `browser ...` command out of an agent reply, if present. Scans
+ * bottom-up (the primer asks for the command on the last line) and tolerates a
+ * surrounding code fence or a leading `$ `/`> ` prompt marker — same shape as
+ * `extractDbCommand`.
+ */
+export function extractBrowserCommand(text) {
+    const lines = text.split('\n');
+    for (let index = lines.length - 1; index >= 0; index--) {
+        const line = lines[index].replace(/^[\s`$>]+/, '').replace(/`+\s*$/, '').trim();
+        if (/^browser\s+(open|list|use|goto|eval|shot|content|close|window)\b/i.test(line))
+            return line;
+    }
+    return null;
+}
+// Primer injected into an ACP agent so it can drive a real browser through the autonomous
+// tool loop. It exposes a deliberately simplified surface — window/headless/mode management
+// is handled by the host, which auto-launches the tab's browser (headless) and auto-opens a
+// window on first use.
+export const BROWSER_PRIMER = [
+    'This host CLI can also drive a real web browser via `browser` commands. Syntax:',
+    '  browser goto <url>     # navigate to a URL (a browser/window opens automatically)',
+    '  browser content        # return the current page\'s rendered text',
+    '  browser eval <js>      # run JavaScript in the page and return the result',
+    'To read a web page, end your reply with exactly one `browser` command on its own final',
+    'line (no code fence, nothing after it). The host runs it and returns the output to you,',
+    'so you can issue further commands. When the task is done, reply with the final answer and',
+    'NO trailing command.',
+].join('\n');

package/dist/browser/index.js

@@ -0,0 +1,124 @@
+import { spawn } from 'node:child_process';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { chromium } from 'playwright';
+import { randomBrowserProfile, acceptLanguage, DEFAULT_CHROME_MAJOR } from '../user-agent.js';
+// Pull the major version out of a Playwright version string like "149.0.7827.55" so the
+// generated UA claims the same Chrome version the engine actually reports via client hints.
+function chromeMajor(version) {
+    const major = Number(version.split('.', 1)[0]);
+    return Number.isFinite(major) ? major : DEFAULT_CHROME_MAJOR;
+}
+// A headless/headed browser is owned per janissary tab: each tab launches its own
+// Playwright process (so modes can differ between tabs) and holds one or more isolated
+// windows. A "window" is a BrowserContext (its own cookies/storage) plus a single Page —
+// the viewport. The Browser handle stays private to the TabBrowser; callers only ever see
+// the BrowserWindow surface and the TabBrowser lifecycle methods.
+// Cap on `content()` output so a large page does not blow up the prompt fed back to an
+// ACP agent. Truncation is flagged in the returned text.
+const CONTENT_LIMIT = 10_000;
+function makeWindow(id, page) {
+    return {
+        id,
+        goto: async (url) => {
+            await page.goto(url, { waitUntil: 'load' });
+            const title = await page.title();
+            return `${title || '(untitled)'} — ${page.url()}`;
+        },
+        eval: async (js) => {
+            const result = await page.evaluate(js);
+            return result === undefined ? 'undefined' : JSON.stringify(result, undefined, 2);
+        },
+        shot: async () => {
+            const temporaryDirectory = mkdtempSync(path.join(tmpdir(), 'janissary-'));
+            const screenshotPath = path.join(temporaryDirectory, `${id}-${Date.now()}.png`);
+            await page.screenshot({ path: screenshotPath });
+            if (process.platform === 'darwin') {
+                // Open the screenshot detached so it never blocks the main process.
+                const child = spawn('open', ['-a', 'Preview', screenshotPath], { stdio: 'ignore', detached: true });
+                child.on('error', () => { });
+                child.unref();
+            }
+            return screenshotPath;
+        },
+        content: async () => {
+            const title = await page.title();
+            const body = await page.evaluate(() => document.body?.textContent ?? ''); // eslint-disable-line unicorn/no-optional-chaining-on-undeclared-variable
+            const text = `${title}\n\n${body}`.trim();
+            return text.length > CONTENT_LIMIT
+                ? `${text.slice(0, CONTENT_LIMIT)}\n… (truncated, ${text.length - CONTENT_LIMIT} more chars)`
+                : text;
+        },
+        url: () => page.url(),
+    };
+}
+/**
+ * Launch a tab's browser. The mode is fixed for the lifetime of the returned TabBrowser's
+ * Playwright process; to switch modes, close all windows (which ends the process) and
+ * launch again.
+ */
+export async function launchTabBrowser(isHeadless) {
+    // `channel: 'chromium'` selects Chromium's new headless mode (a real browser run
+    // headless) rather than the legacy headless shell, which is far more detectable.
+    // `--disable-blink-features=AutomationControlled` drops the automation flag that sets
+    // navigator.webdriver and the "Chrome is being controlled by automated test software"
+    // banner.
+    const browser = await chromium.launch({
+        channel: 'chromium',
+        headless: isHeadless,
+        args: ['--disable-blink-features=AutomationControlled'],
+    });
+    const major = chromeMajor(browser.version());
+    const windows = new Map();
+    return {
+        mode: isHeadless ? 'headless' : 'headed',
+        openWindow: async (id) => {
+            // A fresh, internally consistent fingerprint per window so isolated windows don't
+            // share an identical signature: UA (version pinned to the real engine), matching
+            // client-hint platform header, Accept-Language, timezone, and a common viewport.
+            const profile = randomBrowserProfile(major);
+            const context = await browser.newContext({
+                userAgent: profile.userAgent,
+                locale: profile.locale,
+                timezoneId: profile.timezoneId,
+                viewport: profile.viewport,
+                extraHTTPHeaders: {
+                    'Accept-Language': acceptLanguage(profile.locale),
+                    'Sec-CH-UA-Platform': `"${profile.platform}"`,
+                },
+            });
+            // Ensure navigator.webdriver is never true in any frame of this context.
+            await context.addInitScript(() => {
+                Object.defineProperty(navigator, 'webdriver', { get: () => false });
+            });
+            const page = await context.newPage();
+            const window = makeWindow(id, page);
+            windows.set(id, { window, context });
+            return window;
+        },
+        closeWindow: async (id) => {
+            const entry = windows.get(id);
+            if (!entry)
+                return;
+            windows.delete(id);
+            try {
+                await entry.context.close();
+            }
+            catch {
+                /* already gone */
+            }
+        },
+        window: (id) => windows.get(id)?.window,
+        windowIds: () => [...windows.keys()],
+        close: async () => {
+            windows.clear();
+            try {
+                await browser.close();
+            }
+            catch {
+                /* already gone */
+            }
+        },
+    };
+}

package/dist/browser/tab-helpers.js

@@ -0,0 +1,51 @@
+import { launchTabBrowser } from './index.js';
+export async function ensureCurrentWindow(browsers, label) {
+    let entry = browsers.get(label);
+    if (!entry) {
+        entry = { browser: await launchTabBrowser(true), counter: 0 };
+        browsers.set(label, entry);
+    }
+    if (!entry.current || !entry.browser.window(entry.current)) {
+        const id = `w${++entry.counter}`;
+        await entry.browser.openWindow(id);
+        entry.current = id;
+    }
+    return entry.browser.window(entry.current);
+}
+export async function runGoto(browsers, label, url) {
+    const page = await ensureCurrentWindow(browsers, label);
+    return await page.goto(url);
+}
+export async function runEval(browsers, label, js) {
+    const page = await ensureCurrentWindow(browsers, label);
+    return await page.eval(js);
+}
+export async function runContent(browsers, label) {
+    const page = await ensureCurrentWindow(browsers, label);
+    return await page.content();
+}
+export async function runShot(browsers, label) {
+    const page = await ensureCurrentWindow(browsers, label);
+    const path = await page.shot();
+    const opened = process.platform === 'darwin' ? ' (opening in Preview)' : '';
+    return `Screenshot saved: ${path}${opened}`;
+}
+export async function closeBrowserWindow(browsers, label, id) {
+    const entry = browsers.get(label);
+    if (!entry || !entry.browser.window(id))
+        return `No open connection browser:${id}.`;
+    await entry.browser.closeWindow(id);
+    if (entry.current === id)
+        entry.current = entry.browser.windowIds()[0];
+    if (entry.browser.windowIds().length === 0) {
+        await entry.browser.close();
+        browsers.delete(label);
+    }
+    return `Closed connection browser:${id}.`;
+}
+export function formatList(entry) {
+    const ids = entry?.browser.windowIds() ?? [];
+    if (ids.length === 0)
+        return 'No browser windows.';
+    return ids.map((id) => `${id === entry.current ? '* ' : '  '}browser:${id}`).join('\n');
+}

package/dist/browser/tab.js

@@ -0,0 +1,99 @@
+import { launchTabBrowser } from './index.js';
+import { parseBrowserCommand } from './command.js';
+import { closeBrowserWindow, formatList, runContent, runEval, runGoto, runShot, } from './tab-helpers.js';
+export class BrowserManager {
+    managers;
+    browsers = new Map();
+    constructor(managers) {
+        this.managers = managers;
+    }
+    has(label) {
+        return this.browsers.has(label);
+    }
+    // Live window state for a tab (for the connections panel / `connection list`).
+    info(label) {
+        const entry = this.browsers.get(label);
+        return entry ? { ids: entry.browser.windowIds(), mode: entry.browser.mode, current: entry.current } : null;
+    }
+    closeTab(label) {
+        const entry = this.browsers.get(label);
+        if (entry) {
+            void entry.browser.close();
+            this.browsers.delete(label);
+        }
+    }
+    closeAll() {
+        for (const [, entry] of this.browsers)
+            void entry.browser.close();
+        this.browsers.clear();
+    }
+    // Run a `browser ...` command against a tab's browser, returning text to show/return. Shared by
+    // the interactive `browser` command, `connection close browser:*`, and the ACP tool loop.
+    async run(label, command) {
+        const parsed = parseBrowserCommand(command);
+        if ('error' in parsed)
+            return parsed.error;
+        try {
+            switch (parsed.action) {
+                case 'open': {
+                    let entry = this.browsers.get(label);
+                    const notice = entry && parsed.headed && entry.browser.mode === 'headless'
+                        ? ' (this tab is already running headless; close all windows to relaunch headed)' : '';
+                    if (!entry) {
+                        entry = { browser: await launchTabBrowser(!parsed.headed), counter: 0 };
+                        this.browsers.set(label, entry);
+                    }
+                    const id = `w${++entry.counter}`;
+                    await entry.browser.openWindow(id);
+                    entry.current = id;
+                    return `Opened browser window ${id} (${entry.browser.mode}).${notice}`;
+                }
+                case 'list': {
+                    return formatList(this.browsers.get(label));
+                }
+                case 'use': {
+                    const entry = this.browsers.get(label);
+                    if (!entry || !entry.browser.window(parsed.id))
+                        return `No browser window ${parsed.id}.`;
+                    entry.current = parsed.id;
+                    return `Using browser window ${parsed.id}.`;
+                }
+                case 'close': {
+                    const entry = this.browsers.get(label);
+                    if (!entry?.current)
+                        return 'No browser window to close.';
+                    return await closeBrowserWindow(this.browsers, label, entry.current);
+                }
+                case 'closeWindow': {
+                    return await closeBrowserWindow(this.browsers, label, parsed.id);
+                }
+                case 'goto': {
+                    return await runGoto(this.browsers, label, parsed.url);
+                }
+                case 'eval': {
+                    return await runEval(this.browsers, label, parsed.js);
+                }
+                case 'content': {
+                    return await runContent(this.browsers, label);
+                }
+                case 'shot': {
+                    return await runShot(this.browsers, label);
+                }
+            }
+        }
+        catch (error) {
+            return `Browser error: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        return '';
+    }
+    runInteractive(command, label, onDone) {
+        this.managers.tab.startRunning(label, command);
+        void this.run(label, command)
+            .then((out) => { this.managers.tab.finishRunning(label, out); onDone?.(out); })
+            .catch((error) => {
+            const message = `Browser error: ${error instanceof Error ? error.message : String(error)}`;
+            this.managers.tab.finishRunning(label, message);
+            onDone?.(message);
+        });
+    }
+}

package/dist/browser-command.js

@@ -0,0 +1,104 @@
+// Parser for the `browser` command plus the two helpers the ACP tool loop needs
+// (`extractBrowserCommand` / `BROWSER_PRIMER`), mirroring `parseConnectionCommand`
+// (src/connections.ts) and the `db` equivalents in src/db.ts. Pure — no I/O. The host
+// (src/cli.tsx) performs the actual Playwright actions against the tab's browser.
+const USAGE = 'Usage: browser <open [name] [--headed]|list|use <id>|goto <url>|eval <js>|shot|content|close [id]|window close <id>>';
+// First-position subcommand keywords, exported for tab completion.
+export const BROWSER_SUBCOMMANDS = [
+    'open',
+    'list',
+    'use',
+    'goto',
+    'eval',
+    'shot',
+    'content',
+    'close',
+    'window',
+];
+/** Parse a `browser ...` command. Pure — performs no I/O. */
+export function parseBrowserCommand(input) {
+    const rest = input.trim().replace(/^browser\b\s*/i, '').trim();
+    if (!rest)
+        return { error: USAGE };
+    const [actionRaw, ...tail] = rest.split(/\s+/);
+    const action = actionRaw.toLowerCase();
+    // The argument text after the action verb, with original spacing preserved.
+    const argument = rest.slice(actionRaw.length).trim();
+    switch (action) {
+        case 'open': {
+            const tokens = tail;
+            const isHeaded = tokens.some((t) => t === '--headed' || t === '-H');
+            const name = tokens.find((t) => !t.startsWith('-'));
+            return { action: 'open', name, headed: isHeaded };
+        }
+        case 'list': {
+            return { action: 'list' };
+        }
+        case 'use': {
+            if (!tail[0])
+                return { error: 'Usage: browser use <id>' };
+            return { action: 'use', id: tail[0] };
+        }
+        case 'goto': {
+            if (!argument)
+                return { error: 'Usage: browser goto <url>' };
+            return { action: 'goto', url: argument };
+        }
+        case 'eval': {
+            if (!argument)
+                return { error: 'Usage: browser eval <js>' };
+            return { action: 'eval', js: argument };
+        }
+        case 'shot': {
+            return { action: 'shot' };
+        }
+        case 'content': {
+            return { action: 'content' };
+        }
+        case 'close': {
+            // `browser close <id>` is an alias for `browser window close <id>`; bare
+            // `browser close` closes the current window.
+            if (tail[0])
+                return { action: 'closeWindow', id: tail[0] };
+            return { action: 'close' };
+        }
+        case 'window': {
+            if (tail[0]?.toLowerCase() !== 'close' || !tail[1]) {
+                return { error: 'Usage: browser window close <id>' };
+            }
+            return { action: 'closeWindow', id: tail[1] };
+        }
+        default: {
+            return { error: USAGE };
+        }
+    }
+}
+/**
+ * Pull a proposed `browser ...` command out of an agent reply, if present. Scans
+ * bottom-up (the primer asks for the command on the last line) and tolerates a
+ * surrounding code fence or a leading `$ `/`> ` prompt marker — same shape as
+ * `extractDbCommand`.
+ */
+export function extractBrowserCommand(text) {
+    const lines = text.split('\n');
+    for (let index = lines.length - 1; index >= 0; index--) {
+        const line = lines[index].replace(/^[\s`$>]+/, '').replace(/`+\s*$/, '').trim();
+        if (/^browser\s+(open|list|use|goto|eval|shot|content|close|window)\b/i.test(line))
+            return line;
+    }
+    return null;
+}
+// Primer injected into an ACP agent so it can drive a real browser through the autonomous
+// tool loop. It exposes a deliberately simplified surface — window/headless/mode management
+// is handled by the host, which auto-launches the tab's browser (headless) and auto-opens a
+// window on first use.
+export const BROWSER_PRIMER = [
+    'This host CLI can also drive a real web browser via `browser` commands. Syntax:',
+    '  browser goto <url>     # navigate to a URL (a browser/window opens automatically)',
+    '  browser content        # return the current page\'s rendered text',
+    '  browser eval <js>      # run JavaScript in the page and return the result',
+    'To read a web page, end your reply with exactly one `browser` command on its own final',
+    'line (no code fence, nothing after it). The host runs it and returns the output to you,',
+    'so you can issue further commands. When the task is done, reply with the final answer and',
+    'NO trailing command.',
+].join('\n');

package/dist/browser-tab-helpers.js

@@ -0,0 +1,51 @@
+import { launchTabBrowser } from './browser.js';
+export async function ensureCurrentWindow(browsers, label) {
+    let entry = browsers.get(label);
+    if (!entry) {
+        entry = { browser: await launchTabBrowser(true), counter: 0 };
+        browsers.set(label, entry);
+    }
+    if (!entry.current || !entry.browser.window(entry.current)) {
+        const id = `w${++entry.counter}`;
+        await entry.browser.openWindow(id);
+        entry.current = id;
+    }
+    return entry.browser.window(entry.current);
+}
+export async function runGoto(browsers, label, url) {
+    const page = await ensureCurrentWindow(browsers, label);
+    return await page.goto(url);
+}
+export async function runEval(browsers, label, js) {
+    const page = await ensureCurrentWindow(browsers, label);
+    return await page.eval(js);
+}
+export async function runContent(browsers, label) {
+    const page = await ensureCurrentWindow(browsers, label);
+    return await page.content();
+}
+export async function runShot(browsers, label) {
+    const page = await ensureCurrentWindow(browsers, label);
+    const path = await page.shot();
+    const opened = process.platform === 'darwin' ? ' (opening in Preview)' : '';
+    return `Screenshot saved: ${path}${opened}`;
+}
+export async function closeBrowserWindow(browsers, label, id) {
+    const entry = browsers.get(label);
+    if (!entry || !entry.browser.window(id))
+        return `No open connection browser:${id}.`;
+    await entry.browser.closeWindow(id);
+    if (entry.current === id)
+        entry.current = entry.browser.windowIds()[0];
+    if (entry.browser.windowIds().length === 0) {
+        await entry.browser.close();
+        browsers.delete(label);
+    }
+    return `Closed connection browser:${id}.`;
+}
+export function formatList(entry) {
+    const ids = entry?.browser.windowIds() ?? [];
+    if (ids.length === 0)
+        return 'No browser windows.';
+    return ids.map((id) => `${id === entry.current ? '* ' : '  '}browser:${id}`).join('\n');
+}

package/dist/browser-tab.js

@@ -0,0 +1,99 @@
+import { launchTabBrowser } from './browser.js';
+import { parseBrowserCommand } from './browser-command.js';
+import { closeBrowserWindow, formatList, runContent, runEval, runGoto, runShot, } from './browser-tab-helpers.js';
+export class BrowserManager {
+    managers;
+    browsers = new Map();
+    constructor(managers) {
+        this.managers = managers;
+    }
+    has(label) {
+        return this.browsers.has(label);
+    }
+    // Live window state for a tab (for the connections panel / `connection list`).
+    info(label) {
+        const entry = this.browsers.get(label);
+        return entry ? { ids: entry.browser.windowIds(), mode: entry.browser.mode, current: entry.current } : null;
+    }
+    closeTab(label) {
+        const entry = this.browsers.get(label);
+        if (entry) {
+            void entry.browser.close();
+            this.browsers.delete(label);
+        }
+    }
+    closeAll() {
+        for (const [, entry] of this.browsers)
+            void entry.browser.close();
+        this.browsers.clear();
+    }
+    // Run a `browser ...` command against a tab's browser, returning text to show/return. Shared by
+    // the interactive `browser` command, `connection close browser:*`, and the ACP tool loop.
+    async run(label, command) {
+        const parsed = parseBrowserCommand(command);
+        if ('error' in parsed)
+            return parsed.error;
+        try {
+            switch (parsed.action) {
+                case 'open': {
+                    let entry = this.browsers.get(label);
+                    const notice = entry && parsed.headed && entry.browser.mode === 'headless'
+                        ? ' (this tab is already running headless; close all windows to relaunch headed)' : '';
+                    if (!entry) {
+                        entry = { browser: await launchTabBrowser(!parsed.headed), counter: 0 };
+                        this.browsers.set(label, entry);
+                    }
+                    const id = `w${++entry.counter}`;
+                    await entry.browser.openWindow(id);
+                    entry.current = id;
+                    return `Opened browser window ${id} (${entry.browser.mode}).${notice}`;
+                }
+                case 'list': {
+                    return formatList(this.browsers.get(label));
+                }
+                case 'use': {
+                    const entry = this.browsers.get(label);
+                    if (!entry || !entry.browser.window(parsed.id))
+                        return `No browser window ${parsed.id}.`;
+                    entry.current = parsed.id;
+                    return `Using browser window ${parsed.id}.`;
+                }
+                case 'close': {
+                    const entry = this.browsers.get(label);
+                    if (!entry?.current)
+                        return 'No browser window to close.';
+                    return await closeBrowserWindow(this.browsers, label, entry.current);
+                }
+                case 'closeWindow': {
+                    return await closeBrowserWindow(this.browsers, label, parsed.id);
+                }
+                case 'goto': {
+                    return await runGoto(this.browsers, label, parsed.url);
+                }
+                case 'eval': {
+                    return await runEval(this.browsers, label, parsed.js);
+                }
+                case 'content': {
+                    return await runContent(this.browsers, label);
+                }
+                case 'shot': {
+                    return await runShot(this.browsers, label);
+                }
+            }
+        }
+        catch (error) {
+            return `Browser error: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        return '';
+    }
+    runInteractive(command, label, onDone) {
+        this.managers.tab.startRunning(label, command);
+        void this.run(label, command)
+            .then((out) => { this.managers.tab.finishRunning(label, out); onDone?.(out); })
+            .catch((error) => {
+            const message = `Browser error: ${error instanceof Error ? error.message : String(error)}`;
+            this.managers.tab.finishRunning(label, message);
+            onDone?.(message);
+        });
+    }
+}