10x-chat 0.8.1 → 0.9.0

package/README.md

@@ -11,7 +11,7 @@
 Paste this into your [OpenClaw](https://openclaw.ai) chat to install as a skill:
 
 ```
-https://raw.githubusercontent.com/RealMikeChong/10x-chat/refs/heads/main/skills/10x-chat/SKILL.md
+https://raw.githubusercontent.com/MikeChongCan/10x-chat/refs/heads/main/skills/10x-chat/SKILL.md
 ```
 
 ## Quick Start

package/dist/browser/daemon.d.ts

@@ -1,39 +1,32 @@
-/**
- * Browser daemon — shared long-running Chromium process.
- *
- * Persists a browser server's PID + WS endpoint to disk so that separate
- * CLI invocations can connect to the same browser instead of launching a
- * new one each time.
- *
- * Usage:
- *   const browser = await getOrLaunchBrowserDaemon(headless);
- *   // ... use browser ...
- *   // On close: call stopDaemon() only when tab count hits zero.
- */
-import { type Browser } from 'playwright';
+import type { Browser, BrowserContext, Page } from 'playwright';
+interface WaitForUrlPredicate {
+    mode: 'changes' | 'startsWith';
+    value: string;
+}
 export interface DaemonState {
-    /** PID of the Chromium server process. */
     pid: number;
-    /** Playwright WS endpoint for chromium.connect(). */
-    wsEndpoint: string;
+    port: number;
+    token: string;
     headless: boolean;
     createdAt: string;
 }
+interface SharedBrowserLaunchOptions {
+    headless?: boolean;
+    url?: string;
+}
+interface BrowserSessionProxy {
+    context: BrowserContext;
+    page: Page;
+    close: () => Promise<void>;
+}
 export declare function getDaemonStatePath(): string;
-export declare function readDaemonState(): Promise<DaemonState | null>;
 export declare function clearDaemonState(): Promise<void>;
-/**
- * Stop the daemon browser by killing its server process.
- * Safe to call even if daemon is not running.
- */
+export declare function readDaemonState(): Promise<DaemonState | null>;
 export declare function stopDaemon(): Promise<void>;
-/**
- * Get an existing browser daemon (reconnect) or launch a new one.
- * Returns a Playwright Browser connected to the shared server process.
- *
- * The returned Browser is a client connection — calling browser.close() on it
- * disconnects this client but does NOT stop the server. Call stopDaemon()
- * when you actually want to shut the server down (i.e. last tab closed).
- */
 export declare function getOrLaunchBrowserDaemon(headless?: boolean): Promise<Browser>;
+export declare function launchSharedBrowserSession(opts: SharedBrowserLaunchOptions): Promise<BrowserSessionProxy>;
+export declare function registerDaemonTab(): Promise<string>;
+export declare function unregisterDaemonTab(tabKey: string): Promise<number>;
+export declare function readLiveTabCount(): Promise<number>;
+export type { WaitForUrlPredicate };
 //# sourceMappingURL=daemon.d.ts.map

package/dist/browser/daemon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../src/browser/daemon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,EAAE,KAAK,OAAO,EAAY,MAAM,YAAY,CAAC;AAMpD,MAAM,WAAW,WAAW;IAC1B,0CAA0C;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED,wBAAsB,eAAe,IAAI,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAanE;AAQD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAMtD;AAED;;;GAGG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAUhD;AAED;;;;;;;GAOG;AACH,wBAAsB,wBAAwB,CAAC,QAAQ,UAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CA8BhF"}
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../src/browser/daemon.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAiC,IAAI,EAAE,MAAM,YAAY,CAAC;AAiD/F,UAAU,mBAAmB;IAC3B,IAAI,EAAE,SAAS,GAAG,YAAY,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC;CACf;AASD,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,0BAA0B;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,UAAU,mBAAmB;IAC3B,OAAO,EAAE,cAAc,CAAC;IACxB,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AA2XD,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAItD;AAED,wBAAsB,eAAe,IAAI,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CA2BnE;AAmHD,wBAAsB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAsBhD;AAED,wBAAsB,wBAAwB,CAAC,QAAQ,UAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAGhF;AAED,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,0BAA0B,GAC/B,OAAO,CAAC,mBAAmB,CAAC,CAuC9B;AAED,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC,CASzD;AAED,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAgBzE;AAED,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC,CAUxD;AAED,YAAY,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/browser/daemon.js

@@ -1,101 +1,540 @@
-/**
- * Browser daemon — shared long-running Chromium process.
- *
- * Persists a browser server's PID + WS endpoint to disk so that separate
- * CLI invocations can connect to the same browser instead of launching a
- * new one each time.
- *
- * Usage:
- *   const browser = await getOrLaunchBrowserDaemon(headless);
- *   // ... use browser ...
- *   // On close: call stopDaemon() only when tab count hits zero.
- */
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { readFile, rm } from 'node:fs/promises';
 import path from 'node:path';
-import { chromium } from 'playwright';
+import { fileURLToPath } from 'node:url';
 import { getAppDir } from '../paths.js';
-import { CHROMIUM_ARGS, isProcessAlive } from './process.js';
+import { acquireProfileLock } from './lock.js';
+import { isProcessAlive } from './process.js';
+import { loadStorageState, saveStorageState } from './state.js';
 const DAEMON_FILE = 'browser-daemon.json';
-export function getDaemonStatePath() {
+const DAEMON_LOCK_DIR = path.join(getAppDir(), 'browser-daemon-lock');
+const STARTUP_TIMEOUT_MS = 15_000;
+const HEALTH_TIMEOUT_MS = 3_000;
+class BrowserDaemonHttpClient {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    get headless() {
+        return this.state.headless;
+    }
+    async request(request) {
+        let response;
+        try {
+            response = await fetch(`http://127.0.0.1:${this.state.port}/rpc`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.state.token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(request),
+                signal: AbortSignal.timeout(60_000),
+            });
+        }
+        catch (error) {
+            throw new Error(`Browser daemon request failed: ${getErrorMessage(error)}`);
+        }
+        let body;
+        try {
+            body = (await response.json());
+        }
+        catch (error) {
+            throw new Error(`Browser daemon request failed with invalid response (status ${response.status}): ${getErrorMessage(error)}`);
+        }
+        if (!response.ok || !body.ok) {
+            const message = typeof body === 'object' && body && 'error' in body
+                ? body.error
+                : `Browser daemon request failed with status ${response.status}`;
+            throw new Error(message);
+        }
+        return body;
+    }
+    async stop() {
+        await fetch(`http://127.0.0.1:${this.state.port}/stop`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.state.token}`,
+            },
+            signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS),
+        }).catch(() => {
+            // Best effort; caller falls back to pid kill if needed.
+        });
+    }
+    async getLiveTabCount() {
+        let response;
+        try {
+            response = await fetch(`http://127.0.0.1:${this.state.port}/health`, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${this.state.token}`,
+                },
+                signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS),
+            });
+        }
+        catch (error) {
+            throw new Error(`Browser daemon healthcheck failed: ${getErrorMessage(error)}`);
+        }
+        if (!response.ok) {
+            throw new Error(`Browser daemon healthcheck failed with status ${response.status}`);
+        }
+        let body;
+        try {
+            body = (await response.json());
+        }
+        catch (error) {
+            throw new Error(`Browser daemon healthcheck returned invalid response (status ${response.status}): ${getErrorMessage(error)}`);
+        }
+        return body.activeTabs ?? 0;
+    }
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isDaemonCompatible(state, requestedHeadless) {
+    return !state.headless || state.headless === requestedHeadless;
+}
+function serializeValue(value) {
+    if (value instanceof RegExp) {
+        return {
+            __type: 'regexp',
+            source: value.source,
+            flags: value.flags,
+        };
+    }
+    if (typeof value === 'function') {
+        return {
+            __type: 'function',
+            source: value.toString(),
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => serializeValue(entry));
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value).map(([key, entry]) => [key, serializeValue(entry)]);
+        return Object.fromEntries(entries);
+    }
+    return value;
+}
+function deserializeHandle(client, handle) {
+    switch (handle.handleType) {
+        case 'context':
+            return createRemoteContextProxy(client, handle.id);
+        case 'page':
+            return createRemotePageProxy(client, handle.id, handle.contextId ?? '', handle.url ?? 'about:blank');
+        case 'filechooser':
+            return createRemoteFileChooserProxy(client, handle.id);
+        case 'download':
+            return createRemoteDownloadProxy(client, handle.id, handle.suggestedFilename ?? '');
+    }
+}
+async function decodeResult(client, response, pageState) {
+    if (response.pageState && pageState) {
+        pageState.currentUrl = response.pageState.url;
+    }
+    const { result } = response;
+    if (result &&
+        typeof result === 'object' &&
+        '__handle' in result &&
+        result.__handle === true &&
+        'handleType' in result) {
+        return deserializeHandle(client, result);
+    }
+    return result;
+}
+function createRemoteBrowserProxy(client) {
+    return {
+        newContext: async (options) => {
+            const response = await client.request({
+                kind: 'browser',
+                method: 'newContext',
+                args: [serializeValue(options ?? {})],
+            });
+            const result = await decodeResult(client, response);
+            return result;
+        },
+        close: async () => {
+            // A remote client disconnect should not stop the shared daemon.
+        },
+        isConnected: () => true,
+    };
+}
+function createRemoteContextProxy(client, contextId) {
+    return {
+        newPage: async () => {
+            const response = await client.request({
+                kind: 'context',
+                method: 'newPage',
+                target: { contextId },
+            });
+            const result = await decodeResult(client, response);
+            return result;
+        },
+        close: async () => {
+            await client.request({
+                kind: 'context',
+                method: 'close',
+                target: { contextId },
+            });
+        },
+        storageState: async (options) => {
+            const response = await client.request({
+                kind: 'context',
+                method: 'storageState',
+                target: { contextId },
+                args: [serializeValue(options ?? {})],
+            });
+            const result = await decodeResult(client, response);
+            return result;
+        },
+        cookies: async (urls) => {
+            const response = await client.request({
+                kind: 'context',
+                method: 'cookies',
+                target: { contextId },
+                args: [serializeValue(urls ?? [])],
+            });
+            const result = await decodeResult(client, response);
+            return (result ?? []);
+        },
+    };
+}
+function createRemotePageProxy(client, pageId, contextId, initialUrl) {
+    const pageState = { currentUrl: initialUrl };
+    const context = createRemoteContextProxy(client, contextId);
+    const invoke = async (method, args = []) => {
+        const response = await client.request({
+            kind: 'page',
+            method,
+            target: { pageId },
+            args: args.map((arg) => serializeValue(arg)),
+        });
+        return decodeResult(client, response, pageState);
+    };
+    return {
+        goto: async (url, options) => invoke('goto', [url, options ?? {}]),
+        waitForTimeout: async (timeout) => invoke('waitForTimeout', [timeout]),
+        waitForLoadState: async (state) => invoke('waitForLoadState', [state ?? 'load']),
+        waitForURL: async (url, options) => invoke('waitForURL', [url, options ?? {}]),
+        waitForEvent: async (event, options) => invoke('waitForEvent', [event, options ?? {}]),
+        evaluate: async (pageFunction, arg) => invoke('evaluate', [pageFunction, arg]),
+        close: async () => invoke('close'),
+        title: async () => invoke('title'),
+        url: () => pageState.currentUrl,
+        context: () => context,
+        getByRole: (role, options) => createRemoteLocatorProxy(client, pageId, pageState, [
+            { type: 'getByRole', role, options: serializeValue(options ?? {}) },
+        ]),
+        locator: (selector) => createRemoteLocatorProxy(client, pageId, pageState, [{ type: 'locator', selector }]),
+        keyboard: createRemoteKeyboardProxy(client, pageId, pageState),
+    };
+}
+function createRemoteKeyboardProxy(client, pageId, pageState) {
+    const invoke = async (method, args = []) => {
+        const response = await client.request({
+            kind: 'keyboard',
+            method,
+            target: { pageId },
+            args: args.map((arg) => serializeValue(arg)),
+        });
+        return decodeResult(client, response, pageState);
+    };
+    return {
+        press: async (key, options) => invoke('press', [key, options ?? {}]),
+        type: async (text, options) => invoke('type', [text, options ?? {}]),
+    };
+}
+function createRemoteLocatorProxy(client, pageId, pageState, steps) {
+    const invoke = async (method, args = []) => {
+        const response = await client.request({
+            kind: 'locator',
+            method,
+            target: { pageId, steps },
+            args: args.map((arg) => serializeValue(arg)),
+        });
+        return decodeResult(client, response, pageState);
+    };
+    return {
+        locator: (selector) => createRemoteLocatorProxy(client, pageId, pageState, [
+            ...steps,
+            { type: 'locator', selector },
+        ]),
+        first: () => createRemoteLocatorProxy(client, pageId, pageState, [...steps, { type: 'first' }]),
+        last: () => createRemoteLocatorProxy(client, pageId, pageState, [...steps, { type: 'last' }]),
+        nth: (index) => createRemoteLocatorProxy(client, pageId, pageState, [...steps, { type: 'nth', index }]),
+        waitFor: async (options) => invoke('waitFor', [options ?? {}]),
+        isVisible: async (options) => invoke('isVisible', [options ?? {}]),
+        click: async (options) => invoke('click', [options ?? {}]),
+        fill: async (value) => invoke('fill', [value]),
+        count: async () => invoke('count'),
+        textContent: async (options) => invoke('textContent', [options ?? {}]),
+        innerHTML: async (options) => invoke('innerHTML', [options ?? {}]),
+        setInputFiles: async (files) => invoke('setInputFiles', [files]),
+    };
+}
+function createRemoteFileChooserProxy(client, eventId) {
+    return {
+        setFiles: async (files) => {
+            await client.request({
+                kind: 'event',
+                method: 'setFiles',
+                target: { eventId },
+                args: [serializeValue(files)],
+            });
+        },
+    };
+}
+function createRemoteDownloadProxy(client, eventId, suggestedFilename) {
+    return {
+        suggestedFilename: () => suggestedFilename,
+        saveAs: async (filePath) => {
+            await client.request({
+                kind: 'event',
+                method: 'saveAs',
+                target: { eventId },
+                args: [serializeValue(filePath)],
+            });
+        },
+    };
+}
+function getDaemonStatePathInternal() {
     return path.join(getAppDir(), DAEMON_FILE);
 }
+export function getDaemonStatePath() {
+    return getDaemonStatePathInternal();
+}
+export async function clearDaemonState() {
+    await rm(getDaemonStatePathInternal(), { force: true }).catch(() => {
+        // ignore
+    });
+}
 export async function readDaemonState() {
     try {
-        const raw = await readFile(getDaemonStatePath(), 'utf-8');
+        const raw = await readFile(getDaemonStatePathInternal(), 'utf-8');
         const state = JSON.parse(raw);
-        if (!state.pid || !state.wsEndpoint)
+        if (typeof state.pid !== 'number' ||
+            typeof state.port !== 'number' ||
+            typeof state.token !== 'string') {
             return null;
+        }
         if (!isProcessAlive(state.pid)) {
             await clearDaemonState();
             return null;
         }
-        return state;
+        return {
+            pid: state.pid,
+            port: state.port,
+            token: state.token,
+            headless: Boolean(state.headless),
+            createdAt: typeof state.createdAt === 'string' ? state.createdAt : new Date().toISOString(),
+        };
     }
     catch {
         return null;
     }
 }
-async function writeDaemonState(state) {
-    const p = getDaemonStatePath();
-    await mkdir(path.dirname(p), { recursive: true });
-    await writeFile(p, JSON.stringify(state, null, 2));
-}
-export async function clearDaemonState() {
+async function pingDaemon(state) {
     try {
-        await rm(getDaemonStatePath(), { force: true });
+        const response = await fetch(`http://127.0.0.1:${state.port}/health`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${state.token}`,
+            },
+            signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS),
+        });
+        return response.ok;
     }
     catch {
-        // ignore
+        return false;
+    }
+}
+async function acquireDaemonStartLock() {
+    return acquireProfileLock(DAEMON_LOCK_DIR, {
+        timeoutMs: STARTUP_TIMEOUT_MS * 2,
+        pollMs: 200,
+    });
+}
+function getServerEntryPoint() {
+    const currentFile = fileURLToPath(import.meta.url);
+    const currentDir = path.dirname(currentFile);
+    const jsPath = path.join(currentDir, 'server.js');
+    const tsPath = path.join(currentDir, 'server.ts');
+    const sourcePath = currentFile.endsWith('.ts') ? tsPath : jsPath;
+    if (sourcePath.endsWith('.ts')) {
+        return {
+            command: process.execPath,
+            args: ['--import', 'tsx', sourcePath],
+        };
+    }
+    return {
+        command: process.execPath,
+        args: [sourcePath],
+    };
+}
+async function waitForDaemonReady(headless) {
+    const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const state = await readDaemonState();
+        if (state && isDaemonCompatible(state, headless)) {
+            const healthy = await pingDaemon(state);
+            if (healthy)
+                return state;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
     }
+    throw new Error('Timed out waiting for browser daemon to start');
+}
+async function startDaemon(headless) {
+    const entry = getServerEntryPoint();
+    const child = spawn(entry.command, entry.args, {
+        detached: true,
+        stdio: 'ignore',
+        env: {
+            ...process.env,
+            TEN_X_CHAT_BROWSER_HEADLESS: headless ? '1' : '0',
+            TEN_X_CHAT_BROWSER_STATE_FILE: getDaemonStatePathInternal(),
+        },
+    });
+    child.unref();
+    return waitForDaemonReady(headless);
+}
+async function ensureDaemonState(headless) {
+    const existing = await readDaemonState();
+    if (existing && isDaemonCompatible(existing, headless) && (await pingDaemon(existing))) {
+        return existing;
+    }
+    const lock = await acquireDaemonStartLock();
+    try {
+        const current = await readDaemonState();
+        if (current) {
+            const healthy = await pingDaemon(current);
+            if (healthy && isDaemonCompatible(current, headless)) {
+                return current;
+            }
+            if (healthy) {
+                await new BrowserDaemonHttpClient(current).stop();
+                if (isProcessAlive(current.pid)) {
+                    try {
+                        process.kill(current.pid, 'SIGTERM');
+                    }
+                    catch {
+                        // already gone
+                    }
+                }
+            }
+            await clearDaemonState();
+        }
+        return startDaemon(headless);
+    }
+    finally {
+        await lock.release();
+    }
+}
+async function getDaemonClient(headless = true) {
+    const state = await ensureDaemonState(headless);
+    return new BrowserDaemonHttpClient(state);
 }
-/**
- * Stop the daemon browser by killing its server process.
- * Safe to call even if daemon is not running.
- */
 export async function stopDaemon() {
     const state = await readDaemonState();
-    if (state) {
+    if (!state)
+        return;
+    const healthy = await pingDaemon(state);
+    if (!healthy) {
+        await clearDaemonState();
+        return;
+    }
+    const client = new BrowserDaemonHttpClient(state);
+    await client.stop();
+    if (isProcessAlive(state.pid)) {
         try {
             process.kill(state.pid, 'SIGTERM');
         }
         catch {
-            // already dead
+            // already gone
         }
-        await clearDaemonState();
     }
+    await clearDaemonState();
 }
-/**
- * Get an existing browser daemon (reconnect) or launch a new one.
- * Returns a Playwright Browser connected to the shared server process.
- *
- * The returned Browser is a client connection — calling browser.close() on it
- * disconnects this client but does NOT stop the server. Call stopDaemon()
- * when you actually want to shut the server down (i.e. last tab closed).
- */
 export async function getOrLaunchBrowserDaemon(headless = true) {
-    const existing = await readDaemonState();
-    if (existing) {
+    const client = await getDaemonClient(headless);
+    return createRemoteBrowserProxy(client);
+}
+export async function launchSharedBrowserSession(opts) {
+    const { headless = true, url } = opts;
+    const client = await getDaemonClient(headless);
+    const storageStatePath = await loadStorageState();
+    const browser = createRemoteBrowserProxy(client);
+    const context = (await browser.newContext({
+        viewport: { width: 1280, height: 900 },
+        ...(storageStatePath ? { storageState: storageStatePath } : {}),
+    }));
+    const page = (await context.newPage());
+    try {
+        if (url) {
+            await page.goto(url, { waitUntil: 'domcontentloaded' });
+        }
+    }
+    catch (error) {
+        await context.close().catch(() => {
+            // best effort
+        });
+        throw error;
+    }
+    const close = async () => {
         try {
-            const browser = await chromium.connect(existing.wsEndpoint, { timeout: 5_000 });
-            return browser;
+            await saveStorageState(context);
         }
         catch {
-            // Server died without cleaning up state
-            await clearDaemonState();
+            // best effort
         }
-    }
-    // Launch a new browser server
-    const server = await chromium.launchServer({
-        headless,
-        args: CHROMIUM_ARGS,
-    });
-    const pid = server.process().pid ?? -1;
-    const wsEndpoint = server.wsEndpoint();
-    await writeDaemonState({ pid, wsEndpoint, headless, createdAt: new Date().toISOString() });
-    // Clean up state file if server exits unexpectedly
-    server.process().once('exit', () => {
-        void clearDaemonState();
+        await page.close().catch(() => {
+            // already closed
+        });
+        await context.close().catch(() => {
+            // already closed
+        });
+    };
+    return { context, page, close };
+}
+export async function registerDaemonTab() {
+    const client = await getDaemonClient(true);
+    const response = await client.request({
+        kind: 'tabs',
+        method: 'register',
+        args: [serializeValue(randomUUID())],
     });
-    return chromium.connect(wsEndpoint);
+    const result = await decodeResult(client, response);
+    return typeof result === 'string' ? result : '';
+}
+export async function unregisterDaemonTab(tabKey) {
+    const state = await readDaemonState();
+    if (!state)
+        return 0;
+    const client = new BrowserDaemonHttpClient(state);
+    try {
+        const response = await client.request({
+            kind: 'tabs',
+            method: 'unregister',
+            args: [serializeValue(tabKey)],
+        });
+        const result = await decodeResult(client, response);
+        return typeof result === 'number' ? result : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+export async function readLiveTabCount() {
+    const state = await readDaemonState();
+    if (!state)
+        return 0;
+    const client = new BrowserDaemonHttpClient(state);
+    try {
+        return await client.getLiveTabCount();
+    }
+    catch {
+        return 0;
+    }
 }
 //# sourceMappingURL=daemon.js.map