@jackwener/opencli 1.5.9 → 1.6.1

package/dist/browser/daemon-client.d.ts

@@ -6,7 +6,7 @@
 import type { BrowserSessionInfo } from '../types.js';
 export interface DaemonCommand {
     id: string;
-    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input';
+    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'cdp';
     tabId?: number;
     code?: string;
     workspace?: string;
@@ -21,6 +21,8 @@ export interface DaemonCommand {
     files?: string[];
     /** CSS selector for file input element (set-file-input action) */
     selector?: string;
+    cdpMethod?: string;
+    cdpParams?: Record<string, unknown>;
 }
 export interface DaemonResult {
     id: string;
@@ -28,6 +30,23 @@ export interface DaemonResult {
     data?: unknown;
     error?: string;
 }
+export interface DaemonStatus {
+    ok: boolean;
+    pid: number;
+    uptime: number;
+    extensionConnected: boolean;
+    extensionVersion?: string;
+    pending: number;
+    lastCliRequestTime: number;
+    memoryMB: number;
+    port: number;
+}
+export declare function fetchDaemonStatus(opts?: {
+    timeout?: number;
+}): Promise<DaemonStatus | null>;
+export declare function requestDaemonShutdown(opts?: {
+    timeout?: number;
+}): Promise<boolean>;
 /**
  * Check if daemon is running.
  */

package/dist/browser/daemon-client.js

@@ -8,48 +8,58 @@ import { sleep } from '../utils.js';
 import { isTransientBrowserError } from './errors.js';
 const DAEMON_PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 const DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`;
+const OPENCLI_HEADERS = { 'X-OpenCLI': '1' };
 let _idCounter = 0;
 function generateId() {
     return `cmd_${Date.now()}_${++_idCounter}`;
 }
-/**
- * Check if daemon is running.
- */
-export async function isDaemonRunning() {
+async function requestDaemon(pathname, init) {
+    const { timeout = 2000, headers, ...rest } = init ?? {};
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
     try {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 2000);
-        const res = await fetch(`${DAEMON_URL}/status`, {
-            headers: { 'X-OpenCLI': '1' },
+        return await fetch(`${DAEMON_URL}${pathname}`, {
+            ...rest,
+            headers: { ...OPENCLI_HEADERS, ...headers },
             signal: controller.signal,
         });
+    }
+    finally {
         clearTimeout(timer);
+    }
+}
+export async function fetchDaemonStatus(opts) {
+    try {
+        const res = await requestDaemon('/status', { timeout: opts?.timeout ?? 2000 });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+export async function requestDaemonShutdown(opts) {
+    try {
+        const res = await requestDaemon('/shutdown', { method: 'POST', timeout: opts?.timeout ?? 5000 });
         return res.ok;
     }
     catch {
         return false;
     }
 }
+/**
+ * Check if daemon is running.
+ */
+export async function isDaemonRunning() {
+    return (await fetchDaemonStatus()) !== null;
+}
 /**
  * Check if daemon is running AND the extension is connected.
  */
 export async function isExtensionConnected() {
-    try {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 2000);
-        const res = await fetch(`${DAEMON_URL}/status`, {
-            headers: { 'X-OpenCLI': '1' },
-            signal: controller.signal,
-        });
-        clearTimeout(timer);
-        if (!res.ok)
-            return false;
-        const data = await res.json();
-        return !!data.extensionConnected;
-    }
-    catch {
-        return false;
-    }
+    const status = await fetchDaemonStatus();
+    return !!status?.extensionConnected;
 }
 /**
  * Send a command to the daemon and wait for a result.
@@ -63,15 +73,12 @@ export async function sendCommand(action, params = {}) {
         const id = generateId();
         const command = { id, action, ...params };
         try {
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), 30000);
-            const res = await fetch(`${DAEMON_URL}/command`, {
+            const res = await requestDaemon('/command', {
                 method: 'POST',
-                headers: { 'Content-Type': 'application/json', 'X-OpenCLI': '1' },
+                headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(command),
-                signal: controller.signal,
+                timeout: 30000,
             });
-            clearTimeout(timer);
             const result = (await res.json());
             if (!result.ok) {
                 // Check if error is a transient extension issue worth retrying

package/dist/browser/daemon-client.test.d.ts

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

package/dist/browser/daemon-client.test.js

@@ -0,0 +1,77 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { fetchDaemonStatus, isDaemonRunning, isExtensionConnected, requestDaemonShutdown, } from './daemon-client.js';
+describe('daemon-client', () => {
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('fetchDaemonStatus sends the shared status request and returns parsed data', async () => {
+        const status = {
+            ok: true,
+            pid: 123,
+            uptime: 10,
+            extensionConnected: true,
+            extensionVersion: '1.2.3',
+            pending: 0,
+            lastCliRequestTime: Date.now(),
+            memoryMB: 32,
+            port: 19825,
+        };
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(status),
+        });
+        await expect(fetchDaemonStatus()).resolves.toEqual(status);
+        expect(fetchMock).toHaveBeenCalledWith(expect.stringMatching(/\/status$/), expect.objectContaining({
+            headers: expect.objectContaining({ 'X-OpenCLI': '1' }),
+        }));
+    });
+    it('fetchDaemonStatus returns null on network failure', async () => {
+        vi.mocked(fetch).mockRejectedValue(new Error('ECONNREFUSED'));
+        await expect(fetchDaemonStatus()).resolves.toBeNull();
+    });
+    it('requestDaemonShutdown POSTs to the shared shutdown endpoint', async () => {
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValue({ ok: true });
+        await expect(requestDaemonShutdown()).resolves.toBe(true);
+        expect(fetchMock).toHaveBeenCalledWith(expect.stringMatching(/\/shutdown$/), expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining({ 'X-OpenCLI': '1' }),
+        }));
+    });
+    it('isDaemonRunning reflects shared status availability', async () => {
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                ok: true,
+                pid: 123,
+                uptime: 10,
+                extensionConnected: false,
+                pending: 0,
+                lastCliRequestTime: Date.now(),
+                memoryMB: 16,
+                port: 19825,
+            }),
+        });
+        await expect(isDaemonRunning()).resolves.toBe(true);
+    });
+    it('isExtensionConnected reflects shared status payload', async () => {
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                ok: true,
+                pid: 123,
+                uptime: 10,
+                extensionConnected: false,
+                pending: 0,
+                lastCliRequestTime: Date.now(),
+                memoryMB: 16,
+                port: 19825,
+            }),
+        });
+        await expect(isExtensionConnected()).resolves.toBe(false);
+    });
+});

package/dist/browser/discover.js

@@ -1,30 +1,19 @@
 /**
  * Daemon discovery — checks if the daemon is running.
  */
-import { DEFAULT_DAEMON_PORT } from '../constants.js';
-import { isDaemonRunning } from './daemon-client.js';
+import { fetchDaemonStatus, isDaemonRunning } from './daemon-client.js';
 export { isDaemonRunning };
 /**
  * Check daemon status and return connection info.
  */
 export async function checkDaemonStatus(opts) {
-    try {
-        const port = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), opts?.timeout ?? 2000);
-        try {
-            const res = await fetch(`http://127.0.0.1:${port}/status`, {
-                headers: { 'X-OpenCLI': '1' },
-                signal: controller.signal,
-            });
-            const data = await res.json();
-            return { running: true, extensionConnected: data.extensionConnected, extensionVersion: data.extensionVersion };
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    catch {
+    const status = await fetchDaemonStatus({ timeout: opts?.timeout ?? 2000 });
+    if (!status) {
         return { running: false, extensionConnected: false };
     }
+    return {
+        running: true,
+        extensionConnected: status.extensionConnected,
+        extensionVersion: status.extensionVersion,
+    };
 }

package/dist/browser/page.d.ts

@@ -50,4 +50,8 @@ export declare class Page extends BasePage {
      * payload size limits of base64-in-evaluate.
      */
     setFileInput(files: string[], selector?: string): Promise<void>;
+    cdp(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    nativeClick(x: number, y: number): Promise<void>;
+    nativeType(text: string): Promise<void>;
+    nativeKeyPress(key: string, modifiers?: string[]): Promise<void>;
 }

package/dist/browser/page.js

@@ -171,5 +171,52 @@ export class Page extends BasePage {
             throw new Error('setFileInput returned no count — command may not be supported by the extension');
         }
     }
+    async cdp(method, params = {}) {
+        return sendCommand('cdp', {
+            cdpMethod: method,
+            cdpParams: params,
+            ...this._cmdOpts(),
+        });
+    }
+    async nativeClick(x, y) {
+        await this.cdp('Input.dispatchMouseEvent', {
+            type: 'mousePressed',
+            x, y,
+            button: 'left',
+            clickCount: 1,
+        });
+        await this.cdp('Input.dispatchMouseEvent', {
+            type: 'mouseReleased',
+            x, y,
+            button: 'left',
+            clickCount: 1,
+        });
+    }
+    async nativeType(text) {
+        // Use Input.insertText for reliable Unicode/CJK text insertion
+        await this.cdp('Input.insertText', { text });
+    }
+    async nativeKeyPress(key, modifiers = []) {
+        let modifierFlags = 0;
+        for (const mod of modifiers) {
+            if (mod === 'Alt')
+                modifierFlags |= 1;
+            if (mod === 'Ctrl')
+                modifierFlags |= 2;
+            if (mod === 'Meta')
+                modifierFlags |= 4;
+            if (mod === 'Shift')
+                modifierFlags |= 8;
+        }
+        await this.cdp('Input.dispatchKeyEvent', {
+            type: 'keyDown',
+            key,
+            modifiers: modifierFlags,
+        });
+        await this.cdp('Input.dispatchKeyEvent', {
+            type: 'keyUp',
+            key,
+            modifiers: modifierFlags,
+        });
+    }
 }
-// (End of file)

package/dist/cli-manifest.json

@@ -5445,7 +5445,7 @@
       {
         "name": "op",
         "type": "str",
-        "default": "/home/runner/tmp/gemini-images",
+        "default": "/Users/jakevin/tmp/gemini-images",
         "required": false,
         "help": "Output directory shorthand"
       },
@@ -6432,7 +6432,7 @@
       {
         "name": "path",
         "type": "str",
-        "default": "/home/runner/Downloads/Instagram",
+        "default": "/Users/jakevin/Downloads/Instagram",
         "required": false,
         "help": "Download directory"
       }