@shawnowen/comet-mcp 2.3.1 → 2.4.1

package/dist/observer.d.ts

@@ -0,0 +1,47 @@
+import type { BrowserHealth, BrowserSnapshot, ObserverTabInfo, ObserverTabGroupInfo, ObserverAgentStatus, ObserverBindingInfo, ObserverFilters, ObserverWindowBindingInfo, AgentRegistryEntry } from "./types.js";
+import { type CodexWindowBinding } from "./window-bindings.js";
+export declare function readAgentRegistry(): Record<string, AgentRegistryEntry>;
+export declare function readSessionManifestAgents(): Record<string, AgentRegistryEntry>;
+export declare function classifyAgentStatus(agent: AgentRegistryEntry): ObserverAgentStatus;
+export declare function listCDPTargets(): Promise<ObserverTabInfo[]>;
+interface ExtTabGroup {
+    id: number;
+    collapsed: boolean;
+    color: string;
+    title: string;
+    windowId: number;
+}
+interface ExtTab {
+    id: number;
+    groupId: number;
+    windowId: number;
+    index: number;
+    title: string;
+    url: string;
+    active: boolean;
+}
+export declare function queryTabGroups(): Promise<{
+    groups: ExtTabGroup[];
+    tabs: ExtTab[];
+} | null>;
+export declare function matchTabsToGroups(cdpTargets: ObserverTabInfo[], extData: {
+    groups: ExtTabGroup[];
+    tabs: ExtTab[];
+} | null, agents: Record<string, AgentRegistryEntry>): {
+    groups: ObserverTabGroupInfo[];
+    ungroupedTabs: ObserverTabInfo[];
+};
+export declare function attachBindingMetadata(groups: ObserverTabGroupInfo[], bindings: CodexWindowBinding[]): {
+    groups: ObserverTabGroupInfo[];
+    windows: ObserverWindowBindingInfo[];
+    bindings: ObserverBindingInfo[];
+};
+export declare function getHealth(): Promise<BrowserHealth>;
+export declare function getSnapshot(filters?: ObserverFilters): Promise<BrowserSnapshot>;
+export declare function getStatus(filters?: ObserverFilters): Promise<string>;
+export declare function getDetail(groupName: string, filters?: ObserverFilters): Promise<string>;
+export declare function captureThumbnail(targetId: string): Promise<string | null>;
+export declare function formatHealth(health: BrowserHealth): string;
+export declare function formatSnapshot(snapshot: BrowserSnapshot): string;
+export {};
+//# sourceMappingURL=observer.d.ts.map

package/dist/observer.js

@@ -0,0 +1,516 @@
+// Observer module — non-disruptive browser state observation (Spec 030)
+// Read-only: CDP /json/list + extension bridge + agent-registry.json
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+const __filename_local = fileURLToPath(import.meta.url);
+const __dirname_local = dirname(__filename_local);
+import CDP from "chrome-remote-interface";
+import { canReadBinding, windowBindingStore } from "./window-bindings.js";
+const CDP_PORT = 9222;
+const IDLE_THRESHOLD_MS = 60_000; // 60 seconds → idle
+const ORPHAN_THRESHOLD_MS = 300_000; // 5 minutes → orphaned
+const MANIFEST_PATH = join(homedir(), ".claude", "comet-browser", "session-manifest.json");
+// ---- Agent Registry ----
+export function readAgentRegistry() {
+    // Look for agent-registry.json relative to repo root
+    // The MCP server runs from comet-mcp/, so go up one level
+    const paths = [
+        join(process.cwd(), "scripts", "agent-registry.json"),
+        join(process.cwd(), "..", "scripts", "agent-registry.json"),
+        join(__dirname_local, "..", "..", "scripts", "agent-registry.json"),
+    ];
+    for (const p of paths) {
+        try {
+            const raw = readFileSync(p, "utf-8");
+            const registry = JSON.parse(raw);
+            return registry.agents ?? {};
+        }
+        catch {
+            continue;
+        }
+    }
+    return {};
+}
+export function readSessionManifestAgents() {
+    try {
+        const raw = readFileSync(MANIFEST_PATH, "utf-8");
+        const manifest = JSON.parse(raw);
+        const agents = {};
+        for (const session of manifest.sessions ?? []) {
+            const lastHeartbeat = new Date(session.lastActivity || Date.now()).toISOString();
+            agents[`manifest:${session.sessionKey}`] = {
+                agentId: session.agentId,
+                agentType: "codex",
+                label: session.sessionName ?? session.agentId,
+                lane: 0,
+                status: "active",
+                taskGroup: session.taskThreadId.slice(0, 50),
+                tabGroupId: session.tabGroupId,
+                tabGroupColor: null,
+                currentUrl: session.orchestratorUrl ?? null,
+                taskDescription: session.taskGoal ?? null,
+                startedAt: new Date(session.createdAt || Date.now()).toISOString(),
+                lastHeartbeat,
+                completedAt: null,
+                errorMessage: null,
+            };
+        }
+        return agents;
+    }
+    catch {
+        return {};
+    }
+}
+export function classifyAgentStatus(agent) {
+    const now = Date.now();
+    const hb = new Date(agent.lastHeartbeat).getTime();
+    const elapsed = now - hb;
+    let status;
+    let idleSince = null;
+    if (elapsed <= IDLE_THRESHOLD_MS) {
+        status = "active";
+    }
+    else if (elapsed <= ORPHAN_THRESHOLD_MS) {
+        status = "idle";
+        idleSince = agent.lastHeartbeat;
+    }
+    else {
+        status = "orphaned";
+        idleSince = agent.lastHeartbeat;
+    }
+    return {
+        agentId: agent.agentId,
+        agentType: agent.agentType ?? "unknown",
+        label: agent.label ?? agent.agentId,
+        status,
+        lastHeartbeat: agent.lastHeartbeat,
+        lastActivity: agent.taskDescription ?? null,
+        idleSince,
+    };
+}
+// ---- CDP Targets ----
+export async function listCDPTargets() {
+    const response = await fetch(`http://127.0.0.1:${CDP_PORT}/json/list`);
+    if (!response.ok) {
+        // Try fallback
+        const fallback = await fetch(`http://127.0.0.1:${CDP_PORT}/json`);
+        if (!fallback.ok) {
+            throw new Error(`Cannot connect to CDP on port ${CDP_PORT}. Check browser status.`);
+        }
+        const targets = (await fallback.json());
+        return targets.filter((t) => t.type === "page").map(cdpToTabInfo);
+    }
+    const targets = (await response.json());
+    // If /json/list returns empty, try /json fallback (Comet 145.x)
+    if (targets.length === 0) {
+        const fallback = await fetch(`http://127.0.0.1:${CDP_PORT}/json`);
+        if (fallback.ok) {
+            const fbTargets = (await fallback.json());
+            return fbTargets.filter((t) => t.type === "page").map(cdpToTabInfo);
+        }
+    }
+    return targets.filter((t) => t.type === "page").map(cdpToTabInfo);
+}
+function cdpToTabInfo(t) {
+    return {
+        id: t.id,
+        url: t.url,
+        title: t.title,
+        loadState: "complete", // CDP /json doesn't report load state; default to complete
+        thumbnail: null,
+    };
+}
+export async function queryTabGroups() {
+    try {
+        const { tabGroupsClient } = await import("./tab-groups.js");
+        const groups = await tabGroupsClient.listGroups();
+        const tabs = await tabGroupsClient.listTabs();
+        return { groups, tabs };
+    }
+    catch {
+        return null;
+    }
+}
+// ---- Matching & Assembly ----
+export function matchTabsToGroups(cdpTargets, extData, agents) {
+    if (!extData) {
+        // No extension data — all tabs are ungrouped
+        return { groups: [], ungroupedTabs: cdpTargets };
+    }
+    const { groups: extGroups, tabs: extTabs } = extData;
+    // Build a map of extension tab URL+title → groupId for cross-referencing
+    const extTabByUrl = new Map();
+    for (const t of extTabs) {
+        extTabByUrl.set(`${t.url}|${t.title}`, t);
+    }
+    // Build a map from groupId → agent entry (match by taskGroup === group title)
+    const agentByTaskGroup = new Map();
+    const agentByTabGroupId = new Map();
+    for (const agent of Object.values(agents)) {
+        if (agent.taskGroup) {
+            agentByTaskGroup.set(agent.taskGroup, agent);
+        }
+        if (typeof agent.tabGroupId === "number" && agent.tabGroupId !== null) {
+            agentByTabGroupId.set(agent.tabGroupId, agent);
+        }
+    }
+    // Build group structures
+    const groupMap = new Map();
+    for (const g of extGroups) {
+        const agent = agentByTabGroupId.get(g.id) ?? agentByTaskGroup.get(g.title) ?? null;
+        groupMap.set(g.id, {
+            id: g.id,
+            title: g.title,
+            color: g.color,
+            collapsed: g.collapsed,
+            windowId: g.windowId,
+            tabs: [],
+            tabCount: 0,
+            agent: agent ? classifyAgentStatus(agent) : null,
+            binding: null,
+            bindingStatus: "unbound",
+        });
+    }
+    // Assign CDP targets to groups
+    const ungrouped = [];
+    for (const cdpTab of cdpTargets) {
+        const key = `${cdpTab.url}|${cdpTab.title}`;
+        const extTab = extTabByUrl.get(key);
+        if (extTab && extTab.groupId !== -1 && groupMap.has(extTab.groupId)) {
+            groupMap.get(extTab.groupId).tabs.push(cdpTab);
+        }
+        else {
+            ungrouped.push(cdpTab);
+        }
+    }
+    // Update tab counts
+    for (const g of groupMap.values()) {
+        g.tabCount = g.tabs.length;
+    }
+    return {
+        groups: Array.from(groupMap.values()),
+        ungroupedTabs: ungrouped,
+    };
+}
+function toObserverBindingInfo(binding) {
+    return {
+        bindingId: binding.bindingId,
+        codexSessionId: binding.codexSessionId,
+        projectThreadId: binding.projectThreadId,
+        repoSlug: binding.repoSlug,
+        worktreePath: binding.worktreePath,
+        branchName: binding.branchName,
+        sessionKey: binding.sessionKey,
+        role: binding.role,
+        sidecarContextKey: binding.sidecarContextKey,
+        status: binding.status,
+        windowId: binding.windowId,
+        tabGroupId: binding.tabGroupId,
+        targetId: binding.targetId,
+        runIds: binding.runIds,
+        updatedAt: binding.updatedAt,
+    };
+}
+export function attachBindingMetadata(groups, bindings) {
+    const observerBindings = bindings.map(toObserverBindingInfo);
+    const bindingByWindow = new Map();
+    for (const binding of observerBindings) {
+        const current = bindingByWindow.get(binding.windowId);
+        if (!current || binding.updatedAt > current.updatedAt) {
+            bindingByWindow.set(binding.windowId, binding);
+        }
+    }
+    const liveWindowIds = new Set();
+    const groupsWithBindings = groups.map((group) => {
+        liveWindowIds.add(group.windowId);
+        const binding = bindingByWindow.get(group.windowId) ??
+            observerBindings.find((candidate) => candidate.tabGroupId === group.id) ??
+            null;
+        const bindingStatus = binding?.status ?? "unbound";
+        return {
+            ...group,
+            binding,
+            bindingStatus,
+        };
+    });
+    for (const binding of observerBindings) {
+        liveWindowIds.add(binding.windowId);
+    }
+    const windows = [...liveWindowIds]
+        .sort((a, b) => a - b)
+        .map((windowId) => {
+        const binding = bindingByWindow.get(windowId) ?? null;
+        const bindingStatus = binding?.status ?? "unbound";
+        return {
+            windowId,
+            binding,
+            bindingStatus,
+        };
+    });
+    return { groups: groupsWithBindings, windows, bindings: observerBindings };
+}
+// ---- Health Check ----
+export async function getHealth() {
+    let running = false;
+    let cdpConnected = false;
+    let extensionAvailable = false;
+    let tabCount = 0;
+    let groupCount = 0;
+    // Check CDP
+    try {
+        const resp = await fetch(`http://127.0.0.1:${CDP_PORT}/json/version`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (resp.ok) {
+            running = true;
+            cdpConnected = true;
+        }
+    }
+    catch {
+        // Not running or not reachable
+    }
+    if (cdpConnected) {
+        try {
+            const targets = await listCDPTargets();
+            tabCount = targets.length;
+        }
+        catch {
+            /* already counted as 0 */
+        }
+        try {
+            const extData = await queryTabGroups();
+            if (extData) {
+                extensionAvailable = true;
+                groupCount = extData.groups.length;
+            }
+        }
+        catch {
+            /* extension not available */
+        }
+    }
+    return { running, cdpConnected, extensionAvailable, tabCount, groupCount };
+}
+// ---- Snapshot ----
+export async function getSnapshot(filters) {
+    const health = await getHealth();
+    if (!health.cdpConnected) {
+        return {
+            timestamp: new Date().toISOString(),
+            browser: health,
+            groups: [],
+            ungroupedTabs: [],
+            windows: [],
+            bindings: [],
+            totalTabs: 0,
+            totalGroups: 0,
+        };
+    }
+    const [cdpTargets, extData, agents, bindings] = await Promise.all([
+        listCDPTargets(),
+        queryTabGroups(),
+        Promise.resolve({ ...readSessionManifestAgents(), ...readAgentRegistry() }),
+        windowBindingStore.list().catch(() => []),
+    ]);
+    let { groups, ungroupedTabs } = matchTabsToGroups(cdpTargets, extData, agents);
+    const scopedBindings = filters?.codexIdentity
+        ? bindings.filter((binding) => canReadBinding(filters.codexIdentity, binding))
+        : bindings;
+    if (filters?.codexIdentity) {
+        const allowedWindowIds = new Set(scopedBindings.map((binding) => binding.windowId));
+        const allowedTabGroupIds = new Set(scopedBindings
+            .map((binding) => binding.tabGroupId)
+            .filter((tabGroupId) => typeof tabGroupId === "number"));
+        groups = groups.filter((group) => allowedWindowIds.has(group.windowId) || allowedTabGroupIds.has(group.id));
+        ungroupedTabs = [];
+    }
+    let bindingMetadata = attachBindingMetadata(groups, scopedBindings);
+    groups = bindingMetadata.groups;
+    // Apply filters
+    if (filters?.group) {
+        groups = groups.filter((g) => g.title.toLowerCase().includes(filters.group.toLowerCase()));
+    }
+    if (filters?.agentId) {
+        groups = groups.filter((g) => g.agent?.agentId === filters.agentId);
+    }
+    if (filters?.urlPattern) {
+        const pattern = filters.urlPattern.toLowerCase();
+        groups = groups
+            .map((g) => ({
+            ...g,
+            tabs: g.tabs.filter((t) => t.url.toLowerCase().includes(pattern)),
+            tabCount: g.tabs.filter((t) => t.url.toLowerCase().includes(pattern)).length,
+        }))
+            .filter((g) => g.tabCount > 0);
+        ungroupedTabs = ungroupedTabs.filter((t) => t.url.toLowerCase().includes(pattern));
+    }
+    bindingMetadata = attachBindingMetadata(groups, scopedBindings);
+    groups = bindingMetadata.groups;
+    // Capture thumbnails if requested
+    if (filters?.thumbnails) {
+        for (const g of groups) {
+            for (const tab of g.tabs) {
+                tab.thumbnail = await captureThumbnail(tab.id);
+            }
+        }
+        for (const tab of ungroupedTabs) {
+            tab.thumbnail = await captureThumbnail(tab.id);
+        }
+    }
+    const totalTabs = groups.reduce((sum, g) => sum + g.tabCount, 0) + ungroupedTabs.length;
+    return {
+        timestamp: new Date().toISOString(),
+        browser: health,
+        groups,
+        ungroupedTabs,
+        windows: bindingMetadata.windows,
+        bindings: bindingMetadata.bindings,
+        totalTabs,
+        totalGroups: groups.length,
+    };
+}
+// ---- Status (compact table) ----
+export async function getStatus(filters) {
+    const snapshot = await getSnapshot(filters);
+    if (!snapshot.browser.cdpConnected) {
+        return "Comet browser is not running. Start with: node scripts/session.mjs start --profile oe";
+    }
+    if (snapshot.groups.length === 0 && !snapshot.browser.extensionAvailable) {
+        return ("Tab group/agent data unavailable — extension not detected. Showing tabs only.\n\n" +
+            `${snapshot.ungroupedTabs.length} ungrouped tabs found.`);
+    }
+    const lines = ["Tab Group Status Overview\n"];
+    lines.push("| Group | Color | Agent | Binding | Status | Tabs | Last Activity |");
+    lines.push("|-------|-------|-------|---------|--------|------|---------------|");
+    for (const g of snapshot.groups) {
+        const agent = g.agent;
+        const agentName = agent?.agentId ?? "unknown";
+        const status = agent?.status?.toUpperCase() ?? "UNKNOWN";
+        const binding = g.binding
+            ? `${g.binding.status}:${g.binding.codexSessionId}`
+            : g.bindingStatus.toUpperCase();
+        const lastActivity = agent?.lastHeartbeat
+            ? new Date(agent.lastHeartbeat).toLocaleTimeString("en-US", { hour12: false })
+            : "—";
+        lines.push(`| ${g.title} | ${g.color} | ${agentName} | ${binding} | ${status} | ${g.tabCount} | ${lastActivity} |`);
+    }
+    if (snapshot.ungroupedTabs.length > 0) {
+        lines.push(`\n${snapshot.ungroupedTabs.length} ungrouped tab(s) not shown in table.`);
+    }
+    return lines.join("\n");
+}
+// ---- Detail (single group) ----
+export async function getDetail(groupName, filters) {
+    const snapshot = await getSnapshot(filters);
+    if (!snapshot.browser.cdpConnected) {
+        return "Comet browser is not running. Start with: node scripts/session.mjs start --profile oe";
+    }
+    const group = snapshot.groups.find((g) => g.title.toLowerCase() === groupName.toLowerCase());
+    if (!group) {
+        const available = snapshot.groups.map((g) => g.title).join(", ");
+        return `Tab group '${groupName}' not found.\n\nAvailable groups: ${available || "(none)"}`;
+    }
+    const agent = group.agent;
+    const binding = group.binding
+        ? `${group.binding.status}:${group.binding.bindingId} (${group.binding.codexSessionId})`
+        : "unbound";
+    const lines = [
+        `Tab Group Detail: ${group.title}`,
+        `Color: ${group.color} | Agent: ${agent?.agentId ?? "unknown"} | Binding: ${binding} | Status: ${agent?.status?.toUpperCase() ?? "UNKNOWN"} | Last heartbeat: ${agent?.lastHeartbeat ? new Date(agent.lastHeartbeat).toLocaleTimeString("en-US", { hour12: false }) : "—"}`,
+        "",
+        `Tabs (${group.tabCount}):`,
+    ];
+    for (let i = 0; i < group.tabs.length; i++) {
+        const tab = group.tabs[i];
+        lines.push(`  ${i + 1}. ${tab.title}`);
+        lines.push(`     URL: ${tab.url}`);
+        lines.push(`     Load: ${tab.loadState}`);
+        if (tab.thumbnail) {
+            lines.push(`     Thumbnail: captured (${Math.round((tab.thumbnail.length * 0.75) / 1024)}KB)`);
+        }
+    }
+    return lines.join("\n");
+}
+// ---- Thumbnail Capture ----
+export async function captureThumbnail(targetId) {
+    try {
+        // Get the WebSocket URL for this target
+        const response = await fetch(`http://127.0.0.1:${CDP_PORT}/json/list`);
+        if (!response.ok)
+            return null;
+        const targets = (await response.json());
+        const target = targets.find((t) => t.id === targetId);
+        if (!target?.webSocketDebuggerUrl)
+            return null;
+        // Skip extension pages
+        if (target.url.startsWith("chrome-extension://") || target.url.startsWith("chrome://")) {
+            return null;
+        }
+        // Temporarily attach to capture screenshot
+        const client = await CDP({ target: target.webSocketDebuggerUrl });
+        try {
+            await client.Page.enable();
+            const result = await Promise.race([
+                client.Page.captureScreenshot({ format: "png", quality: 50 }),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("thumbnail timeout")), 2000)),
+            ]);
+            return result.data;
+        }
+        finally {
+            try {
+                await client.close();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+}
+// ---- Formatters ----
+export function formatHealth(health) {
+    return [
+        `Browser: ${health.running ? "running" : "not running"}`,
+        `CDP: ${health.cdpConnected ? "connected" : "disconnected"}`,
+        `Extension: ${health.extensionAvailable ? "available" : "unavailable"}`,
+        `Tabs: ${health.tabCount}`,
+        `Groups: ${health.groupCount}`,
+    ].join(" | ");
+}
+export function formatSnapshot(snapshot) {
+    if (!snapshot.browser.cdpConnected) {
+        return "Comet browser is not running. Start with: node scripts/session.mjs start --profile oe";
+    }
+    const lines = [
+        `Browser Snapshot (${snapshot.timestamp})`,
+        `${snapshot.totalTabs} tabs across ${snapshot.totalGroups} groups`,
+    ];
+    if (!snapshot.browser.extensionAvailable && snapshot.groups.length === 0) {
+        lines.push("\nWarning: Tab group/agent data unavailable — extension not detected. Showing tabs only.");
+    }
+    for (const g of snapshot.groups) {
+        const agentStr = g.agent
+            ? `agent: ${g.agent.agentId} [${g.agent.status.toUpperCase()}${g.agent.status === "idle" ? ` since ${new Date(g.agent.idleSince).toLocaleTimeString("en-US", { hour12: false })}` : ""}]`
+            : "agent: unknown";
+        const bindingStr = g.binding
+            ? `binding: ${g.binding.status}:${g.binding.bindingId} owner=${g.binding.codexSessionId}`
+            : `binding: ${g.bindingStatus}`;
+        lines.push(`\n## ${g.title} (${g.color}) — ${agentStr} — ${bindingStr}`);
+        for (let i = 0; i < g.tabs.length; i++) {
+            const t = g.tabs[i];
+            lines.push(`  ${i + 1}. ${t.title} | ${t.url} | ${t.loadState}`);
+        }
+    }
+    if (snapshot.ungroupedTabs.length > 0) {
+        lines.push("\n## Ungrouped");
+        for (let i = 0; i < snapshot.ungroupedTabs.length; i++) {
+            const t = snapshot.ungroupedTabs[i];
+            lines.push(`  ${i + 1}. ${t.title} | ${t.url} | ${t.loadState}`);
+        }
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=observer.js.map

package/dist/session-registry.d.ts

@@ -0,0 +1,57 @@
+import { CometCDPClient } from "./cdp-client.js";
+import { CometAI } from "./comet-ai.js";
+import type { AgentSession, ManifestEntry, TabGroupColor, ConsumerRole } from "./types.js";
+export interface RegisterOptions {
+    agentId?: string;
+    taskThreadId?: string;
+    url?: string;
+    tabGroupColor?: TabGroupColor;
+    port?: number;
+    role?: ConsumerRole;
+    taskGoal?: string;
+    codexSessionId?: string;
+    projectThreadId?: string;
+    projectThreadFamily?: string;
+    worktreePath?: string;
+    repoSlug?: string;
+    branchName?: string;
+    codexSessionRole?: string;
+    codexSessionKey?: string;
+    strictCodexIdentity?: boolean;
+    profile?: string;
+}
+export declare function generateSessionName(taskGoal: string): string;
+export interface ReleaseOptions {
+    closeTabs?: boolean;
+    updateGroupColor?: TabGroupColor;
+    taskStatus?: "success" | "failed" | "abandoned" | "in-progress";
+}
+export declare class SessionRegistry {
+    private sessions;
+    private currentSessionKey;
+    private tabGroupMutex;
+    register(options?: RegisterOptions): Promise<AgentSession & {
+        cdpClient: CometCDPClient;
+        cometAI: CometAI;
+    }>;
+    get(sessionKey: string): (AgentSession & {
+        cdpClient: CometCDPClient;
+        cometAI: CometAI;
+    }) | undefined;
+    getCurrent(): (AgentSession & {
+        cdpClient: CometCDPClient;
+        cometAI: CometAI;
+    }) | undefined;
+    updateSessionUrl(sessionKey: string, orchestratorUrl: string): void;
+    getManifestEntryByThread(taskThreadId: string): ManifestEntry | undefined;
+    release(sessionKey: string, options?: ReleaseOptions): Promise<void>;
+    reapOrphans(): Promise<number>;
+    ensureBrowserRunning(port?: number): Promise<string>;
+    private createTabGroup;
+    private getWindowIdForTarget;
+    private loadManifest;
+    private writeManifest;
+    private persistManifest;
+}
+export declare const sessionRegistry: SessionRegistry;
+//# sourceMappingURL=session-registry.d.ts.map