@pasko70/pibo 1.0.0

package/dist/sessions/bindings.js

@@ -0,0 +1,41 @@
+import { randomUUID } from "node:crypto";
+export function createPiboSessionId() {
+    return randomUUID();
+}
+export function createSessionBinding(input, now = new Date().toISOString()) {
+    return {
+        sessionKey: input.sessionKey ?? createDefaultSessionKey(input),
+        sessionId: input.sessionId ?? createPiboSessionId(),
+        parentSessionKey: input.parentSessionKey,
+        parentSessionId: input.parentSessionId,
+        channel: input.channel,
+        externalId: input.externalId,
+        originalProfile: input.defaultProfile,
+        workspace: input.workspace,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+export function createDefaultSessionKey(input) {
+    return `${input.channel}:${input.externalId}`;
+}
+export class InMemorySessionBindingStore {
+    bySessionKey = new Map();
+    byChannelExternalId = new Map();
+    get(sessionKey) {
+        return this.bySessionKey.get(sessionKey);
+    }
+    list() {
+        return [...this.bySessionKey.values()];
+    }
+    resolve(input) {
+        const channelExternalId = createDefaultSessionKey(input);
+        const existing = this.byChannelExternalId.get(channelExternalId);
+        if (existing)
+            return existing;
+        const binding = createSessionBinding(input);
+        this.bySessionKey.set(binding.sessionKey, binding);
+        this.byChannelExternalId.set(channelExternalId, binding);
+        return binding;
+    }
+}

package/dist/sessions/sqlite-store.js

@@ -0,0 +1,154 @@
+import { mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { createPiboSession, matchesFindInput, } from "./store.js";
+export class SqlitePiboSessionStore {
+    db;
+    constructor(path) {
+        const resolvedPath = path === ":memory:" ? path : resolve(path);
+        if (resolvedPath !== ":memory:") {
+            mkdirSync(dirname(resolvedPath), { recursive: true });
+        }
+        this.db = new DatabaseSync(resolvedPath);
+        this.db.exec("PRAGMA busy_timeout = 5000");
+        if (resolvedPath !== ":memory:")
+            this.db.exec("PRAGMA journal_mode = WAL");
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS pibo_sessions (
+				id TEXT PRIMARY KEY,
+				pi_session_id TEXT NOT NULL UNIQUE,
+				channel TEXT NOT NULL,
+				kind TEXT NOT NULL,
+				profile TEXT NOT NULL,
+				owner_scope TEXT,
+				parent_id TEXT,
+				origin_id TEXT,
+				workspace TEXT,
+				title TEXT,
+				metadata_json TEXT,
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL,
+				FOREIGN KEY(parent_id) REFERENCES pibo_sessions(id),
+				FOREIGN KEY(origin_id) REFERENCES pibo_sessions(id)
+			);
+
+			CREATE INDEX IF NOT EXISTS idx_pibo_sessions_owner
+				ON pibo_sessions(owner_scope, updated_at);
+			CREATE INDEX IF NOT EXISTS idx_pibo_sessions_parent
+				ON pibo_sessions(parent_id, updated_at);
+			CREATE INDEX IF NOT EXISTS idx_pibo_sessions_origin
+				ON pibo_sessions(origin_id, updated_at);
+			CREATE INDEX IF NOT EXISTS idx_pibo_sessions_channel_kind
+				ON pibo_sessions(channel, kind, updated_at);
+		`);
+    }
+    get(id) {
+        const row = this.db.prepare("SELECT * FROM pibo_sessions WHERE id = ?").get(id);
+        return row ? sessionFromRow(row) : undefined;
+    }
+    list() {
+        return this.db.prepare("SELECT * FROM pibo_sessions ORDER BY updated_at DESC").all().map(sessionFromRow);
+    }
+    create(input) {
+        const session = createPiboSession(input);
+        this.db
+            .prepare(`
+				INSERT INTO pibo_sessions (
+					id,
+					pi_session_id,
+					channel,
+					kind,
+					profile,
+					owner_scope,
+					parent_id,
+					origin_id,
+					workspace,
+					title,
+					metadata_json,
+					created_at,
+					updated_at
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+			`)
+            .run(session.id, session.piSessionId, session.channel, session.kind, session.profile, session.ownerScope ?? null, session.parentId ?? null, session.originId ?? null, session.workspace ?? null, session.title ?? null, JSON.stringify(session.metadata ?? {}), session.createdAt, session.updatedAt);
+        const created = this.get(session.id);
+        if (!created)
+            throw new Error(`Failed to create Pibo session "${session.id}"`);
+        return created;
+    }
+    update(id, input) {
+        const existing = this.get(id);
+        if (!existing)
+            return undefined;
+        const updated = {
+            ...existing,
+            piSessionId: input.piSessionId ?? existing.piSessionId,
+            profile: input.profile ?? existing.profile,
+            ownerScope: input.ownerScope ?? existing.ownerScope,
+            parentId: input.parentId === null ? undefined : input.parentId ?? existing.parentId,
+            originId: input.originId === null ? undefined : input.originId ?? existing.originId,
+            workspace: input.workspace === null ? undefined : input.workspace ?? existing.workspace,
+            title: input.title === null ? undefined : input.title ?? existing.title,
+            metadata: input.metadata ?? existing.metadata,
+            updatedAt: new Date().toISOString(),
+        };
+        this.db
+            .prepare(`
+				UPDATE pibo_sessions SET
+					pi_session_id = ?,
+					profile = ?,
+					owner_scope = ?,
+					parent_id = ?,
+					origin_id = ?,
+					workspace = ?,
+					title = ?,
+					metadata_json = ?,
+					updated_at = ?
+				WHERE id = ?
+			`)
+            .run(updated.piSessionId, updated.profile, updated.ownerScope ?? null, updated.parentId ?? null, updated.originId ?? null, updated.workspace ?? null, updated.title ?? null, JSON.stringify(updated.metadata ?? {}), updated.updatedAt, id);
+        return this.get(id);
+    }
+    delete(id) {
+        const result = this.db.prepare("DELETE FROM pibo_sessions WHERE id = ?").run(id);
+        return Number(result.changes ?? 0) > 0;
+    }
+    find(input) {
+        return this.list().filter((session) => matchesFindInput(session, input));
+    }
+    close() {
+        this.db.close();
+    }
+}
+export function createDefaultPiboSessionStore(cwd = process.cwd()) {
+    return new SqlitePiboSessionStore(resolve(cwd, ".pibo/pibo-sessions.sqlite"));
+}
+function sessionFromRow(row) {
+    return {
+        id: row.id,
+        piSessionId: row.pi_session_id,
+        channel: row.channel,
+        kind: row.kind,
+        profile: row.profile,
+        ownerScope: row.owner_scope ?? undefined,
+        parentId: row.parent_id ?? undefined,
+        originId: row.origin_id ?? undefined,
+        workspace: row.workspace ?? undefined,
+        title: row.title ?? undefined,
+        metadata: parseMetadata(row.metadata_json),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function parseMetadata(value) {
+    if (!value)
+        return {};
+    try {
+        const parsed = JSON.parse(value);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}

package/dist/sessions/store.js

@@ -0,0 +1,125 @@
+import { randomUUID } from "node:crypto";
+export function createPiboSessionId() {
+    return `ps_${randomUUID()}`;
+}
+export function createPiSessionId() {
+    return randomUUID();
+}
+export function createPiboSession(input, now = new Date().toISOString()) {
+    return {
+        id: input.id ?? createPiboSessionId(),
+        piSessionId: input.piSessionId ?? createPiSessionId(),
+        channel: input.channel,
+        kind: input.kind,
+        profile: input.profile,
+        ownerScope: input.ownerScope,
+        parentId: input.parentId,
+        originId: input.originId,
+        workspace: input.workspace,
+        title: input.title,
+        metadata: input.metadata ?? {},
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+export class InMemoryPiboSessionStore {
+    byId = new Map();
+    byPiSessionId = new Map();
+    get(id) {
+        return this.byId.get(id);
+    }
+    list() {
+        return this.sort([...this.byId.values()]);
+    }
+    create(input) {
+        const session = createPiboSession(input);
+        if (this.byId.has(session.id)) {
+            throw new Error(`Pibo session "${session.id}" already exists`);
+        }
+        if (this.byPiSessionId.has(session.piSessionId)) {
+            throw new Error(`Pi session "${session.piSessionId}" is already attached to a Pibo session`);
+        }
+        this.set(session);
+        return session;
+    }
+    update(id, input) {
+        const existing = this.byId.get(id);
+        if (!existing)
+            return undefined;
+        if (input.piSessionId && input.piSessionId !== existing.piSessionId) {
+            const attached = this.byPiSessionId.get(input.piSessionId);
+            if (attached && attached.id !== id) {
+                throw new Error(`Pi session "${input.piSessionId}" is already attached to Pibo session "${attached.id}"`);
+            }
+        }
+        const updated = {
+            ...existing,
+            piSessionId: input.piSessionId ?? existing.piSessionId,
+            profile: input.profile ?? existing.profile,
+            ownerScope: input.ownerScope ?? existing.ownerScope,
+            parentId: input.parentId === null ? undefined : input.parentId ?? existing.parentId,
+            originId: input.originId === null ? undefined : input.originId ?? existing.originId,
+            workspace: input.workspace === null ? undefined : input.workspace ?? existing.workspace,
+            title: input.title === null ? undefined : input.title ?? existing.title,
+            metadata: input.metadata ?? existing.metadata,
+            updatedAt: new Date().toISOString(),
+        };
+        this.set(updated, existing.piSessionId);
+        return updated;
+    }
+    delete(id) {
+        const existing = this.byId.get(id);
+        if (!existing)
+            return false;
+        this.byId.delete(id);
+        this.byPiSessionId.delete(existing.piSessionId);
+        return true;
+    }
+    find(input) {
+        return this.sort([...this.byId.values()].filter((session) => matchesFindInput(session, input)));
+    }
+    set(session, previousPiSessionId) {
+        this.byId.set(session.id, session);
+        if (previousPiSessionId && previousPiSessionId !== session.piSessionId) {
+            this.byPiSessionId.delete(previousPiSessionId);
+        }
+        this.byPiSessionId.set(session.piSessionId, session);
+    }
+    sort(sessions) {
+        return sessions.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    }
+}
+export function matchesFindInput(session, input) {
+    if (input.ids && !input.ids.includes(session.id))
+        return false;
+    if (input.channel !== undefined && session.channel !== input.channel)
+        return false;
+    if (input.kind !== undefined && session.kind !== input.kind)
+        return false;
+    if (input.ownerScope !== undefined && session.ownerScope !== input.ownerScope)
+        return false;
+    if (input.parentId !== undefined) {
+        if (input.parentId === null) {
+            if (session.parentId !== undefined)
+                return false;
+        }
+        else if (session.parentId !== input.parentId) {
+            return false;
+        }
+    }
+    if (input.originId !== undefined && session.originId !== input.originId)
+        return false;
+    if (input.profile !== undefined && session.profile !== input.profile)
+        return false;
+    if (input.metadata && !metadataMatches(session.metadata, input.metadata))
+        return false;
+    return true;
+}
+function metadataMatches(metadata, expected) {
+    const actual = metadata ?? {};
+    for (const [key, value] of Object.entries(expected)) {
+        if (JSON.stringify(actual[key]) !== JSON.stringify(value))
+            return false;
+    }
+    return true;
+}

package/dist/shared/trace-order.js

@@ -0,0 +1,83 @@
+export const TRACE_SOURCE_RANK = {
+    transcript: 0,
+    "event-log": 1,
+    live: 2,
+};
+export const TRACE_PHASE_RANK = {
+    "user.message": 0,
+    "agent.turn": 1,
+    "model.reasoning": 2,
+    "tool.call": 3,
+    "agent.delegation": 3,
+    "agent.async": 4,
+    "tool.result": 5,
+    "execution.command": 6,
+    "yielded.run": 7,
+    "assistant.message": 8,
+    error: 9,
+};
+export function transcriptTraceOrder(transcriptIndex, contentPartIndex, type) {
+    return {
+        sourceRank: TRACE_SOURCE_RANK.transcript,
+        turnSeq: transcriptIndex,
+        transcriptIndex,
+        contentPartIndex,
+        phaseRank: TRACE_PHASE_RANK[type],
+    };
+}
+export function eventTraceOrder(eventSequence, type) {
+    return {
+        sourceRank: TRACE_SOURCE_RANK["event-log"],
+        turnSeq: eventSequence ?? Number.MAX_SAFE_INTEGER,
+        eventSequence,
+        phaseRank: TRACE_PHASE_RANK[type],
+    };
+}
+export function liveTraceOrder(streamId, streamFrameIndex, type) {
+    const streamOrder = streamId ?? Number.MAX_SAFE_INTEGER;
+    const frameIndex = streamFrameIndex ?? Number.MAX_SAFE_INTEGER;
+    return {
+        sourceRank: TRACE_SOURCE_RANK.live,
+        turnSeq: streamOrder,
+        streamId: streamOrder,
+        streamFrameIndex: frameIndex,
+        phaseRank: TRACE_PHASE_RANK[type],
+    };
+}
+export function parseTraceStreamFrameId(value) {
+    const [stream, frame] = value.split(":");
+    if (stream === undefined || frame === undefined)
+        return undefined;
+    const streamId = Number(stream);
+    const frameIndex = Number(frame);
+    if (!Number.isInteger(streamId) || streamId < 0)
+        return undefined;
+    if (!Number.isInteger(frameIndex) || frameIndex < 0)
+        return undefined;
+    return { streamId, frameIndex };
+}
+export function childTraceOrder(parent, type) {
+    if (!parent)
+        return undefined;
+    return {
+        ...parent,
+        contentPartIndex: (parent.contentPartIndex ?? 0) + 0.1,
+        phaseRank: TRACE_PHASE_RANK[type],
+    };
+}
+export function compareTraceOrder(left, right) {
+    if (!left && !right)
+        return 0;
+    if (!left)
+        return 1;
+    if (!right)
+        return -1;
+    return (left.turnSeq - right.turnSeq ||
+        (left.transcriptIndex ?? Number.MAX_SAFE_INTEGER) - (right.transcriptIndex ?? Number.MAX_SAFE_INTEGER) ||
+        (left.eventSequence ?? Number.MAX_SAFE_INTEGER) - (right.eventSequence ?? Number.MAX_SAFE_INTEGER) ||
+        (left.streamId ?? Number.MAX_SAFE_INTEGER) - (right.streamId ?? Number.MAX_SAFE_INTEGER) ||
+        (left.streamFrameIndex ?? Number.MAX_SAFE_INTEGER) - (right.streamFrameIndex ?? Number.MAX_SAFE_INTEGER) ||
+        (left.contentPartIndex ?? 0) - (right.contentPartIndex ?? 0) ||
+        left.phaseRank - right.phaseRank ||
+        left.sourceRank - right.sourceRank);
+}

package/dist/subagents/tool.js

@@ -0,0 +1,63 @@
+import { createHash } from "node:crypto";
+import { Type } from "@mariozechner/pi-ai";
+import { defineTool } from "@mariozechner/pi-coding-agent";
+function hashPart(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+function toolNamePart(value) {
+    const normalized = value.trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
+    return normalized || `subagent_${hashPart(value)}`;
+}
+export function createSubagentToolName(subagentName) {
+    return `pibo_subagent_${toolNamePart(subagentName)}`;
+}
+export function createSubagentToolDefinitions(subagents, runner) {
+    const seen = new Set();
+    const definitions = [];
+    for (const subagent of subagents) {
+        if (subagent.enabled === false)
+            continue;
+        const toolName = createSubagentToolName(subagent.name);
+        if (seen.has(toolName)) {
+            throw new Error(`Duplicate subagent tool name "${toolName}"`);
+        }
+        seen.add(toolName);
+        definitions.push(createSubagentToolDefinition(subagent, runner));
+    }
+    return definitions;
+}
+function createSubagentToolDefinition(subagent, runner) {
+    const name = createSubagentToolName(subagent.name);
+    return defineTool({
+        name,
+        label: `Pibo Subagent ${subagent.name}`,
+        description: subagent.description ??
+            `Send a message to the ${subagent.name} subagent. Use threadKey to continue the same subagent session.`,
+        promptSnippet: subagent.description ??
+            `Send a message to the ${subagent.name} subagent. Pass the same threadKey when you want to continue the same subagent session.`,
+        executionMode: "parallel",
+        parameters: Type.Object({
+            message: Type.String({ description: "Message to send to the subagent" }),
+            threadKey: Type.Optional(Type.String({
+                description: "Stable key for continuing a previous subagent conversation. Omit it to create a new subagent session.",
+            })),
+        }),
+        async execute(toolCallId, params) {
+            const result = await runner.runSubagent({
+                subagent,
+                message: params.message,
+                threadKey: params.threadKey,
+                toolCallId,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result.reply.text,
+                    },
+                ],
+                details: result,
+            };
+        },
+    });
+}

package/dist/tools/browser-use-cdp.js

@@ -0,0 +1,207 @@
+const DEFAULT_CDP_URL = 'http://127.0.0.1:56663';
+const DEFAULT_TIMEOUT_MS = 2500;
+const CHAT_TARGET_PROBE = `(() => {
+  const text = String(document.body?.innerText || "");
+  const textareas = [...document.querySelectorAll("textarea")].map((textarea) => ({
+    placeholder: textarea.placeholder || "",
+    disabled: Boolean(textarea.disabled),
+    value: textarea.value || "",
+  }));
+  return {
+    title: document.title || "",
+    text: text.slice(0, 3000),
+    textareas,
+  };
+})()`;
+export async function listBrowserUseCdpTargets(options = {}) {
+    const cdpUrl = normalizeCdpUrl(options.cdpUrl);
+    const probe = options.probe !== false;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const targets = await fetchChromeTargets(cdpUrl, timeoutMs);
+    const rows = [];
+    for (const target of targets) {
+        const row = normalizeChromeTarget(target);
+        if (probe && row.url.includes('/apps/chat') && row.webSocketDebuggerUrl) {
+            rows.push(await probeChatTarget(row, timeoutMs));
+        }
+        else {
+            rows.push(row);
+        }
+    }
+    return rows;
+}
+export function selectBestChatTarget(targets) {
+    return targets
+        .filter((target) => target.url.includes('/apps/chat'))
+        .filter((target) => target.webSocketDebuggerUrl)
+        .filter((target) => target.auth !== 'unauthenticated')
+        .filter((target) => target.composer)
+        .sort((left, right) => scoreChatTarget(right) - scoreChatTarget(left))[0];
+}
+export function formatBrowserUseTargets(targets) {
+    const lines = ['id\turl\tauth\tcomposer\ttitle'];
+    for (const target of targets) {
+        const composer = target.composer ? 'yes' : 'no';
+        const title = target.probeError ? `${target.title} (${target.probeError})` : target.title;
+        lines.push(`${target.id}\t${target.url}\t${target.auth}\t${composer}\t${title}`);
+    }
+    return lines.join('\n');
+}
+export function printAttachChatExports(target, cdpUrl = DEFAULT_CDP_URL) {
+    console.log(`export PIBO_CDP_URL=${shellQuote(normalizeCdpUrl(cdpUrl))}`);
+    console.log(`export PIBO_CDP_TARGET_ID=${shellQuote(target.id)}`);
+    console.log(`export PIBO_CDP_TARGET_WS=${shellQuote(target.webSocketDebuggerUrl ?? '')}`);
+    console.log(`export PIBO_CHAT_URL=${shellQuote(target.url)}`);
+}
+function normalizeCdpUrl(value) {
+    return (value || DEFAULT_CDP_URL).replace(/\/+$/, '');
+}
+async function fetchChromeTargets(cdpUrl, timeoutMs) {
+    const response = await fetchWithTimeout(`${cdpUrl}/json/list`, timeoutMs);
+    if (!response.ok) {
+        throw new Error(`Chrome target discovery failed: ${response.status} ${response.statusText}`);
+    }
+    const payload = await response.json();
+    if (!Array.isArray(payload))
+        throw new Error('Chrome target discovery returned invalid JSON');
+    return payload;
+}
+async function fetchWithTimeout(url, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function normalizeChromeTarget(target) {
+    return {
+        id: stringValue(target.id),
+        type: stringValue(target.type),
+        title: stringValue(target.title),
+        url: stringValue(target.url),
+        webSocketDebuggerUrl: optionalStringValue(target.webSocketDebuggerUrl),
+        auth: 'unknown',
+        composer: false,
+        textareaCount: 0,
+    };
+}
+async function probeChatTarget(target, timeoutMs) {
+    try {
+        const probe = await evaluateCdp(target.webSocketDebuggerUrl, CHAT_TARGET_PROBE, timeoutMs);
+        return applyProbe(target, probe);
+    }
+    catch (error) {
+        return {
+            ...target,
+            probeError: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function applyProbe(target, probe) {
+    const text = stringValue(probe.text);
+    const textareas = Array.isArray(probe.textareas) ? probe.textareas : [];
+    const composer = textareas.some((textarea) => {
+        if (!isRecord(textarea))
+            return false;
+        return textarea.disabled !== true;
+    });
+    return {
+        ...target,
+        title: stringValue(probe.title) || target.title,
+        auth: classifyAuth(text, composer),
+        composer,
+        textareaCount: textareas.length,
+    };
+}
+function classifyAuth(text, composer) {
+    if (/Unauthenticated|Sign in with Google|Sign in/i.test(text))
+        return 'unauthenticated';
+    if (composer)
+        return 'authenticated';
+    if (/[^\s@]+@[^\s@]+\.[^\s@]+/.test(text))
+        return 'authenticated';
+    return 'unknown';
+}
+function scoreChatTarget(target) {
+    return ((target.auth === 'authenticated' ? 100 : 0) +
+        (target.composer ? 50 : 0) +
+        (target.url.includes('/sessions/') ? 20 : 0) +
+        (target.url.includes('/rooms/') ? 10 : 0));
+}
+async function evaluateCdp(webSocketUrl, expression, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const socket = new WebSocket(webSocketUrl);
+        let nextId = 0;
+        let settled = false;
+        const timer = setTimeout(() => fail(new Error('Timed out waiting for CDP target')), timeoutMs);
+        function settle() {
+            if (settled)
+                return false;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                socket.close();
+            }
+            catch {
+                // The target may fail before the WebSocket reaches OPEN.
+            }
+            return true;
+        }
+        function succeed(value) {
+            if (settle())
+                resolve(value);
+        }
+        function fail(error) {
+            if (settle())
+                reject(error);
+        }
+        function send(method, params) {
+            const id = ++nextId;
+            socket.send(JSON.stringify({ id, method, params }));
+            return id;
+        }
+        socket.addEventListener('open', () => {
+            send('Runtime.evaluate', { expression, returnByValue: true });
+        });
+        socket.addEventListener('message', (event) => {
+            const message = parseJson(String(event.data));
+            if (!isRecord(message) || typeof message.id !== 'number')
+                return;
+            if (isRecord(message.error)) {
+                fail(new Error(JSON.stringify(message.error)));
+                return;
+            }
+            const result = isRecord(message.result) ? message.result : undefined;
+            const runtimeResult = result && isRecord(result.result) ? result.result : undefined;
+            const value = runtimeResult && isRecord(runtimeResult.value) ? runtimeResult.value : {};
+            succeed(value);
+        });
+        socket.addEventListener('error', () => {
+            fail(new Error('CDP WebSocket error'));
+        });
+    });
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value : '';
+}
+function optionalStringValue(value) {
+    const text = stringValue(value);
+    return text || undefined;
+}
+function parseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}