@jackwener/opencli 0.7.8 → 0.7.9

package/dist/_debug.d.ts

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

package/dist/_debug.js

@@ -0,0 +1,7 @@
+import { render, evalExpr } from '../pipeline/template.js';
+const ctx = { item: { first: 'X', second: 'Y' } };
+console.log('evalExpr item.first:', JSON.stringify(evalExpr('item.first', ctx)));
+console.log('evalExpr item.second:', JSON.stringify(evalExpr('item.second', ctx)));
+const template = '$' + '{{ item.first }}-$' + '{{ item.second }}';
+console.log('template:', JSON.stringify(template));
+console.log('render result:', JSON.stringify(render(template, ctx)));

package/dist/browser-tab.d.ts

@@ -0,0 +1,2 @@
+import type { IPage } from './types.js';
+export declare function withTemporaryTab<T>(page: IPage, fn: () => Promise<T>): Promise<T>;

package/dist/browser-tab.js

@@ -0,0 +1,30 @@
+function tabCount(tabs) {
+    if (Array.isArray(tabs))
+        return tabs.length;
+    if (typeof tabs === 'string') {
+        const matches = tabs.match(/Tab \d+/g);
+        return matches ? matches.length : 0;
+    }
+    return 0;
+}
+export async function withTemporaryTab(page, fn) {
+    let closeIndex = null;
+    try {
+        const before = tabCount(await page.tabs());
+        await page.newTab();
+        const after = tabCount(await page.tabs());
+        closeIndex = Math.max(after - 1, before);
+        if (closeIndex >= 0) {
+            await page.selectTab(closeIndex);
+        }
+        return await fn();
+    }
+    finally {
+        if (closeIndex != null && closeIndex >= 0) {
+            try {
+                await page.closeTab(closeIndex);
+            }
+            catch { }
+        }
+    }
+}

package/dist/browser.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Browser interaction via Playwright MCP Bridge extension.
+ * Connects to an existing Chrome browser through the extension.
+ */
+import { withTimeoutMs } from './runtime.js';
+type ConnectFailureKind = 'missing-token' | 'extension-timeout' | 'extension-not-installed' | 'mcp-init' | 'process-exit' | 'unknown';
+type PlaywrightMCPState = 'idle' | 'connecting' | 'connected' | 'closing' | 'closed';
+type ConnectFailureInput = {
+    kind: ConnectFailureKind;
+    timeout: number;
+    hasExtensionToken: boolean;
+    tokenFingerprint?: string | null;
+    stderr?: string;
+    exitCode?: number | null;
+    rawMessage?: string;
+};
+export declare function getTokenFingerprint(token: string | undefined): string | null;
+export declare function formatBrowserConnectError(input: ConnectFailureInput): Error;
+declare function createJsonRpcRequest(method: string, params?: Record<string, any>): {
+    id: number;
+    message: string;
+};
+import type { IPage } from './types.js';
+/**
+ * Page abstraction wrapping JSON-RPC calls to Playwright MCP.
+ */
+export declare class Page implements IPage {
+    private _request;
+    constructor(_request: (method: string, params?: Record<string, any>) => Promise<any>);
+    call(method: string, params?: Record<string, any>): Promise<any>;
+    goto(url: string): Promise<void>;
+    evaluate(js: string): Promise<any>;
+    snapshot(opts?: {
+        interactive?: boolean;
+        compact?: boolean;
+        maxDepth?: number;
+        raw?: boolean;
+    }): Promise<any>;
+    click(ref: string): Promise<void>;
+    typeText(ref: string, text: string): Promise<void>;
+    pressKey(key: string): Promise<void>;
+    wait(options: number | {
+        text?: string;
+        time?: number;
+        timeout?: number;
+    }): Promise<void>;
+    tabs(): Promise<any>;
+    closeTab(index?: number): Promise<void>;
+    newTab(): Promise<void>;
+    selectTab(index: number): Promise<void>;
+    networkRequests(includeStatic?: boolean): Promise<any>;
+    consoleMessages(level?: string): Promise<any>;
+    scroll(direction?: string, _amount?: number): Promise<void>;
+    autoScroll(options?: {
+        times?: number;
+        delayMs?: number;
+    }): Promise<void>;
+    installInterceptor(pattern: string): Promise<void>;
+    getInterceptedRequests(): Promise<any[]>;
+}
+/**
+ * Playwright MCP process manager.
+ */
+export declare class PlaywrightMCP {
+    private static _activeInsts;
+    private static _cleanupRegistered;
+    private static _registerGlobalCleanup;
+    private _proc;
+    private _buffer;
+    private _pending;
+    private _initialTabIdentities;
+    private _closingPromise;
+    private _state;
+    private _page;
+    get state(): PlaywrightMCPState;
+    private _sendRequest;
+    private _rejectPendingRequests;
+    private _resetAfterFailedConnect;
+    connect(opts?: {
+        timeout?: number;
+    }): Promise<Page>;
+    close(): Promise<void>;
+}
+declare function extractTabEntries(raw: any): Array<{
+    index: number;
+    identity: string;
+}>;
+declare function diffTabIndexes(initialIdentities: string[], currentTabs: Array<{
+    index: number;
+    identity: string;
+}>): number[];
+declare function appendLimited(current: string, chunk: string, limit: number): string;
+declare function buildMcpArgs(input: {
+    mcpPath: string;
+    executablePath?: string | null;
+}): string[];
+export declare const __test__: {
+    createJsonRpcRequest: typeof createJsonRpcRequest;
+    extractTabEntries: typeof extractTabEntries;
+    diffTabIndexes: typeof diffTabIndexes;
+    appendLimited: typeof appendLimited;
+    buildMcpArgs: typeof buildMcpArgs;
+    withTimeoutMs: typeof withTimeoutMs;
+};
+export {};