@deadragdoll/tellymcp 0.0.12 → 0.0.14

package/dist/services/features/telegram-mcp/src/features/browser-attach/model/browserRecordingBundle.js

@@ -0,0 +1,536 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserRecordingBundleWriter = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const client_1 = require("../../../shared/integrations/terminal/client");
+function sanitizeSegment(value) {
+    const normalized = value
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/gu, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/gu, "-")
+        .replace(/^-+/u, "")
+        .replace(/-+$/u, "");
+    return normalized || "recording";
+}
+function padNumber(value, length = 2) {
+    return String(value).padStart(length, "0");
+}
+function formatLocalTimestamp(date) {
+    return `${date.getFullYear()}-${padNumber(date.getMonth() + 1)}-${padNumber(date.getDate())}T${padNumber(date.getHours())}:${padNumber(date.getMinutes())}:${padNumber(date.getSeconds())}.${padNumber(date.getMilliseconds(), 3)}`;
+}
+function formatTimestampForDir(date) {
+    return formatLocalTimestamp(date).replace(/[:.]/gu, "-");
+}
+function normalizeRecordedTimestamp(rawValue) {
+    const trimmed = rawValue?.trim();
+    if (!trimmed) {
+        return formatLocalTimestamp(new Date());
+    }
+    const parsed = new Date(trimmed);
+    if (Number.isNaN(parsed.getTime())) {
+        return formatLocalTimestamp(new Date());
+    }
+    return formatLocalTimestamp(parsed);
+}
+function formatJsonLine(value) {
+    return Buffer.from(`${JSON.stringify(value)}\n`, "utf8");
+}
+function sanitizeRequestId(value) {
+    return value
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/gu, "-")
+        .replace(/^-+/u, "")
+        .replace(/-+$/u, "") || "request";
+}
+function detectMimeTypeFromHeaders(headers) {
+    const match = headers?.find((header) => header.name.trim().toLowerCase() === "content-type");
+    const value = match?.value?.trim();
+    return value || undefined;
+}
+async function allocateBundleDirName(config, session, tabTitle) {
+    const exchangeRoot = await (0, client_1.ensureXchangeDir)(config.terminal, session.cwd || "", config.exchange.dir);
+    const webRoot = node_path_1.default.resolve(exchangeRoot, "web");
+    await (0, promises_1.mkdir)(webRoot, { recursive: true });
+    const baseName = `${sanitizeSegment(tabTitle)}-${formatTimestampForDir(new Date())}`;
+    let attempt = 1;
+    while (attempt < 1000) {
+        const candidate = attempt === 1 ? baseName : `${baseName}-${attempt}`;
+        const candidatePath = node_path_1.default.resolve(webRoot, candidate);
+        try {
+            await (0, promises_1.mkdir)(candidatePath);
+            return candidate;
+        }
+        catch (error) {
+            if (error &&
+                typeof error === "object" &&
+                "code" in error &&
+                error.code === "EEXIST") {
+                attempt += 1;
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error("Could not allocate a unique browser recording bundle directory.");
+}
+class BrowserRecordingBundleWriter {
+    config;
+    logger;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    async create(input) {
+        if (!input.session.cwd?.trim()) {
+            throw new Error("Workspace cwd is not registered for this console.");
+        }
+        const bundleDirName = await allocateBundleDirName(this.config, input.session, input.tabTitle);
+        const bundleRelativePath = `web/${bundleDirName}`;
+        const exchangeRoot = await (0, client_1.ensureXchangeDir)(this.config.terminal, input.session.cwd, this.config.exchange.dir);
+        const bundlePath = node_path_1.default.resolve(exchangeRoot, bundleRelativePath);
+        for (const segment of [
+            bundleRelativePath,
+            `${bundleRelativePath}/pages`,
+            `${bundleRelativePath}/network`,
+            `${bundleRelativePath}/network/requests`,
+            `${bundleRelativePath}/console`,
+        ]) {
+            await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, input.session.cwd, this.config.exchange.dir, `${segment}/.keep`, Buffer.from("", "utf8"));
+        }
+        const startedAt = formatLocalTimestamp(new Date());
+        const record = {
+            sessionId: input.sessionId,
+            backend: "firefox-attached",
+            recordingId: input.recordingId,
+            instanceId: input.instanceId,
+            tabId: input.tabId,
+            ...(input.tabTitle ? { tabTitle: input.tabTitle } : {}),
+            ...(input.tabUrl ? { tabUrl: input.tabUrl } : {}),
+            bundleDirName,
+            bundleRelativePath,
+            bundlePath,
+            startedAt,
+            status: "recording",
+            eventCount: 0,
+        };
+        const sessionJson = {
+            recording_id: record.recordingId,
+            backend: record.backend,
+            session_id: record.sessionId,
+            session_label: input.session.label || input.session.sessionId,
+            instance_id: record.instanceId,
+            tab_id: record.tabId,
+            ...(record.tabTitle ? { tab_title: record.tabTitle } : {}),
+            ...(record.tabUrl ? { tab_url: record.tabUrl } : {}),
+            started_at: record.startedAt,
+            status: record.status,
+            bundle_dir_name: record.bundleDirName,
+            bundle_relative_path: record.bundleRelativePath,
+            bundle_path: record.bundlePath,
+            workspace_dir: input.session.cwd,
+            exchange_dir: node_path_1.default.resolve(input.session.cwd, this.config.exchange.dir),
+            files: {
+                timeline: "timeline.ndjson",
+                session: "session.json",
+                pages: "pages",
+                network: "network",
+                network_index: "network/index.ndjson",
+                network_requests: "network/requests",
+                console: "console",
+            },
+        };
+        await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, input.session.cwd, this.config.exchange.dir, `${bundleRelativePath}/session.json`, Buffer.from(`${JSON.stringify(sessionJson, null, 2)}\n`, "utf8"));
+        const state = {
+            record,
+            session: input.session,
+            pageCounter: 0,
+            snapshotCounter: 0,
+            requestCounter: 0,
+            requestArtifacts: new Map(),
+        };
+        await this.appendEvent(state, {
+            kind: "session_started",
+            status: "recording",
+        });
+        this.logger.info("Browser recording bundle created", {
+            sessionId: input.sessionId,
+            recordingId: input.recordingId,
+            bundlePath,
+            tabId: input.tabId,
+            tabTitle: input.tabTitle,
+        });
+        return state;
+    }
+    async appendEvent(state, event) {
+        const at = normalizeRecordedTimestamp(event.at);
+        state.record.eventCount += 1;
+        state.record.lastEventAt = at;
+        let relPath;
+        let pageId = state.currentPageId;
+        if (event.kind === "page_snapshot") {
+            const targetUrl = event.url?.trim() || state.currentPageUrl || "";
+            if (!pageId || (targetUrl && targetUrl !== state.currentPageUrl)) {
+                state.pageCounter += 1;
+                pageId = `page-${String(state.pageCounter).padStart(3, "0")}`;
+                state.currentPageId = pageId;
+                state.currentPageUrl = targetUrl || state.currentPageUrl;
+            }
+            state.snapshotCounter += 1;
+            relPath = `${state.record.bundleRelativePath}/pages/${pageId}/snapshot-${String(state.snapshotCounter).padStart(4, "0")}.html`;
+            await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, state.session.cwd || "", this.config.exchange.dir, relPath, Buffer.from(String(event.html || ""), "utf8"));
+            await this.appendJsonLine(state, `${state.record.bundleRelativePath}/pages/events.ndjson`, {
+                at,
+                page_id: pageId,
+                reason: event.reason || "snapshot",
+                url: event.url || state.currentPageUrl || "",
+                title: event.title || state.record.tabTitle || "",
+                ready_state: event.ready_state || "",
+                html_rel_path: relPath.replace(`${state.record.bundleRelativePath}/`, ""),
+            });
+        }
+        else if (event.kind === "console_event") {
+            await this.appendJsonLine(state, `${state.record.bundleRelativePath}/console/events.ndjson`, {
+                at,
+                level: event.level || "log",
+                text: event.text || "",
+                args: event.args || [],
+                url: event.url || state.currentPageUrl || "",
+                title: event.title || state.record.tabTitle || "",
+                page_id: state.currentPageId,
+            });
+        }
+        else if (event.kind.startsWith("network_") ||
+            event.kind === "cookies_snapshot") {
+            const networkEvent = await this.materializeNetworkBodyArtifact(state, event);
+            const requestArtifact = await this.upsertNetworkRequestArtifact(state, networkEvent);
+            await this.appendJsonLine(state, `${state.record.bundleRelativePath}/network/index.ndjson`, {
+                at,
+                page_id: state.currentPageId,
+                request_id: networkEvent.request_id,
+                kind: networkEvent.kind,
+                method: networkEvent.method,
+                url: networkEvent.url,
+                resource_type: networkEvent.resource_type,
+                status_code: networkEvent.status_code,
+                summary: this.buildSummary(networkEvent),
+                ...(requestArtifact
+                    ? {
+                        seq: requestArtifact.seq,
+                        request_bundle_rel_path: requestArtifact.requestDirRelPath.replace(`${state.record.bundleRelativePath}/`, ""),
+                        meta_rel_path: requestArtifact.metaFileRelPath.replace(`${state.record.bundleRelativePath}/`, ""),
+                        request_rel_path: requestArtifact.requestFileRelPath.replace(`${state.record.bundleRelativePath}/`, ""),
+                        response_rel_path: requestArtifact.responseFileRelPath.replace(`${state.record.bundleRelativePath}/`, ""),
+                        ...(this.extractBodyRelPath(requestArtifact)
+                            ? {
+                                body_rel_path: this.extractBodyRelPath(requestArtifact),
+                            }
+                            : {}),
+                    }
+                    : {}),
+            });
+        }
+        if (event.kind === "navigation") {
+            const nextUrl = event.url?.trim() || "";
+            if (nextUrl && nextUrl !== state.currentPageUrl) {
+                state.currentPageUrl = nextUrl;
+            }
+        }
+        if (event.kind === "session_stopped") {
+            state.record.status = "stopped";
+            state.record.stoppedAt = at;
+        }
+        const eventRecord = event;
+        const requestId = typeof eventRecord.request_id === "string" ? eventRecord.request_id : "";
+        const eventUrl = typeof eventRecord.url === "string" ? eventRecord.url : "";
+        const eventTitle = typeof eventRecord.title === "string" ? eventRecord.title : "";
+        const timelineEntry = {
+            at,
+            kind: event.kind,
+            ...(state.currentPageId ? { page_id: state.currentPageId } : {}),
+            ...(relPath
+                ? {
+                    rel_path: relPath.replace(`${state.record.bundleRelativePath}/`, ""),
+                }
+                : {}),
+            ...(requestId.trim()
+                ? { request_id: requestId.trim() }
+                : {}),
+            ...(eventUrl.trim()
+                ? { url: eventUrl.trim() }
+                : {}),
+            ...(eventTitle.trim()
+                ? { title: eventTitle.trim() }
+                : {}),
+            summary: this.buildSummary(event),
+        };
+        await this.appendJsonLine(state, `${state.record.bundleRelativePath}/timeline.ndjson`, timelineEntry);
+        await this.writeSessionJson(state);
+        return state;
+    }
+    async finalizeExisting(input) {
+        const state = {
+            record: { ...input.record },
+            session: input.session,
+            currentPageId: undefined,
+            currentPageUrl: input.record.tabUrl,
+            pageCounter: 0,
+            snapshotCounter: 0,
+            requestCounter: 0,
+            requestArtifacts: new Map(),
+        };
+        await this.appendEvent(state, {
+            kind: "session_stopped",
+            status: "stopped",
+        });
+        return state.record;
+    }
+    async appendJsonLine(state, relativePath, value) {
+        await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, state.session.cwd || "", this.config.exchange.dir, relativePath, formatJsonLine(value), { append: true });
+    }
+    async materializeNetworkBodyArtifact(state, event) {
+        const mimeType = detectMimeTypeFromHeaders(event.headers);
+        return {
+            ...event,
+            ...(mimeType ? { body_mime_type: mimeType } : {}),
+            ...(typeof event.body_text === "string" ? { body_encoding: "utf8" } : {}),
+        };
+    }
+    async upsertNetworkRequestArtifact(state, event) {
+        const requestId = typeof event.request_id === "string" && event.request_id.trim()
+            ? event.request_id.trim()
+            : "";
+        if (!requestId) {
+            return null;
+        }
+        let artifact = state.requestArtifacts.get(requestId);
+        if (!artifact) {
+            state.requestCounter += 1;
+            const requestDirRelPath = `${state.record.bundleRelativePath}/network/requests/${String(state.requestCounter).padStart(6, "0")}-${sanitizeRequestId(requestId)}`;
+            artifact = {
+                seq: state.requestCounter,
+                requestId,
+                requestDirRelPath,
+                metaFileRelPath: `${requestDirRelPath}/meta.json`,
+                requestFileRelPath: `${requestDirRelPath}/request.json`,
+                responseFileRelPath: `${requestDirRelPath}/response.json`,
+                request: {
+                    request_id: requestId,
+                },
+                response: {
+                    request_id: requestId,
+                },
+            };
+            state.requestArtifacts.set(requestId, artifact);
+            await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, state.session.cwd || "", this.config.exchange.dir, `${requestDirRelPath}/.keep`, Buffer.from("", "utf8"));
+        }
+        const kind = typeof event.kind === "string" ? event.kind : "";
+        const artifactEvent = { ...event };
+        delete artifactEvent.body_base64;
+        delete artifactEvent.body_text;
+        delete artifactEvent.body_file_rel_path;
+        delete artifactEvent.body_mime_type;
+        delete artifactEvent.body_encoding;
+        if (kind === "network_request" || kind === "network_request_headers") {
+            artifact.request = {
+                ...artifact.request,
+                ...artifactEvent,
+                seq: artifact.seq,
+            };
+        }
+        else {
+            artifact.response = {
+                ...artifact.response,
+                ...artifactEvent,
+                seq: artifact.seq,
+            };
+        }
+        await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, state.session.cwd || "", this.config.exchange.dir, artifact.requestFileRelPath, Buffer.from(`${JSON.stringify(artifact.request, null, 2)}\n`, "utf8"));
+        await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, state.session.cwd || "", this.config.exchange.dir, artifact.responseFileRelPath, Buffer.from(`${JSON.stringify(artifact.response, null, 2)}\n`, "utf8"));
+        await this.writeRequestArtifactMeta(state, artifact);
+        await this.materializeRequestBodyArtifact(state, artifact, event, kind);
+        return artifact;
+    }
+    async materializeRequestBodyArtifact(state, artifact, event, kind) {
+        const bodyBase64 = typeof event.body_base64 === "string" && event.body_base64.trim()
+            ? event.body_base64.trim()
+            : "";
+        const bodyText = typeof event.body_text === "string" ? event.body_text : "";
+        const bodyMimeType = typeof event.body_mime_type === "string" && event.body_mime_type.trim()
+            ? event.body_mime_type.trim()
+            : undefined;
+        let bodyFileRelPath;
+        let bodyEncoding;
+        if (bodyBase64) {
+            bodyFileRelPath = `${artifact.requestDirRelPath}/${kind}-body.bin`;
+            bodyEncoding = "base64";
+            await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, state.session.cwd || "", this.config.exchange.dir, bodyFileRelPath, Buffer.from(bodyBase64, "base64"));
+        }
+        else if (bodyText.length > 16384) {
+            bodyFileRelPath = `${artifact.requestDirRelPath}/${kind}-body.txt`;
+            bodyEncoding = "utf8";
+            await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, state.session.cwd || "", this.config.exchange.dir, bodyFileRelPath, Buffer.from(bodyText, "utf8"));
+        }
+        if (kind === "network_request" || kind === "network_request_headers") {
+            artifact.request = {
+                ...artifact.request,
+                ...(bodyMimeType ? { body_mime_type: bodyMimeType } : {}),
+                ...(bodyEncoding ? { body_encoding: bodyEncoding } : {}),
+                ...(bodyFileRelPath
+                    ? {
+                        body_file_rel_path: bodyFileRelPath.replace(`${state.record.bundleRelativePath}/`, ""),
+                    }
+                    : {}),
+                ...(!bodyFileRelPath && bodyText ? { body_text: bodyText } : {}),
+                ...(bodyFileRelPath && bodyText
+                    ? {
+                        body_text_preview: bodyText.slice(0, 4096),
+                    }
+                    : {}),
+            };
+        }
+        else {
+            artifact.response = {
+                ...artifact.response,
+                ...(bodyMimeType ? { body_mime_type: bodyMimeType } : {}),
+                ...(bodyEncoding ? { body_encoding: bodyEncoding } : {}),
+                ...(bodyFileRelPath
+                    ? {
+                        body_file_rel_path: bodyFileRelPath.replace(`${state.record.bundleRelativePath}/`, ""),
+                    }
+                    : {}),
+                ...(!bodyFileRelPath && bodyText ? { body_text: bodyText } : {}),
+                ...(bodyFileRelPath && bodyText
+                    ? {
+                        body_text_preview: bodyText.slice(0, 4096),
+                    }
+                    : {}),
+            };
+        }
+        await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, state.session.cwd || "", this.config.exchange.dir, artifact.requestFileRelPath, Buffer.from(`${JSON.stringify(artifact.request, null, 2)}\n`, "utf8"));
+        await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, state.session.cwd || "", this.config.exchange.dir, artifact.responseFileRelPath, Buffer.from(`${JSON.stringify(artifact.response, null, 2)}\n`, "utf8"));
+        await this.writeRequestArtifactMeta(state, artifact);
+    }
+    extractBodyRelPath(artifact) {
+        const responseBody = typeof artifact.response.body_file_rel_path === "string"
+            ? artifact.response.body_file_rel_path
+            : "";
+        if (responseBody.trim()) {
+            return responseBody.trim();
+        }
+        const requestBody = typeof artifact.request.body_file_rel_path === "string"
+            ? artifact.request.body_file_rel_path
+            : "";
+        return requestBody.trim() || undefined;
+    }
+    async writeRequestArtifactMeta(state, artifact) {
+        const requestAt = typeof artifact.request.at === "string" && artifact.request.at.trim()
+            ? artifact.request.at.trim()
+            : undefined;
+        const responseAt = typeof artifact.response.at === "string" && artifact.response.at.trim()
+            ? artifact.response.at.trim()
+            : undefined;
+        const method = typeof artifact.request.method === "string" && artifact.request.method.trim()
+            ? artifact.request.method.trim()
+            : undefined;
+        const url = typeof artifact.request.url === "string" && artifact.request.url.trim()
+            ? artifact.request.url.trim()
+            : typeof artifact.response.url === "string" && artifact.response.url.trim()
+                ? artifact.response.url.trim()
+                : undefined;
+        const resourceType = typeof artifact.request.resource_type === "string" &&
+            artifact.request.resource_type.trim()
+            ? artifact.request.resource_type.trim()
+            : typeof artifact.response.resource_type === "string" &&
+                artifact.response.resource_type.trim()
+                ? artifact.response.resource_type.trim()
+                : undefined;
+        const statusCode = typeof artifact.response.status_code === "number"
+            ? artifact.response.status_code
+            : undefined;
+        const requestBodyRelPath = typeof artifact.request.body_file_rel_path === "string" &&
+            artifact.request.body_file_rel_path.trim()
+            ? artifact.request.body_file_rel_path.trim()
+            : undefined;
+        const responseBodyRelPath = typeof artifact.response.body_file_rel_path === "string" &&
+            artifact.response.body_file_rel_path.trim()
+            ? artifact.response.body_file_rel_path.trim()
+            : undefined;
+        const meta = {
+            seq: artifact.seq,
+            request_id: artifact.requestId,
+            ...(requestAt ? { request_at: requestAt } : {}),
+            ...(responseAt ? { response_at: responseAt } : {}),
+            ...(method ? { method } : {}),
+            ...(url ? { url } : {}),
+            ...(resourceType ? { resource_type: resourceType } : {}),
+            ...(typeof statusCode === "number" ? { status_code: statusCode } : {}),
+            request_rel_path: artifact.requestFileRelPath.replace(`${state.record.bundleRelativePath}/`, ""),
+            response_rel_path: artifact.responseFileRelPath.replace(`${state.record.bundleRelativePath}/`, ""),
+            ...(requestBodyRelPath ? { request_body_rel_path: requestBodyRelPath } : {}),
+            ...(responseBodyRelPath ? { response_body_rel_path: responseBodyRelPath } : {}),
+        };
+        await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, state.session.cwd || "", this.config.exchange.dir, artifact.metaFileRelPath, Buffer.from(`${JSON.stringify(meta, null, 2)}\n`, "utf8"));
+    }
+    async writeSessionJson(state) {
+        await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, state.session.cwd || "", this.config.exchange.dir, `${state.record.bundleRelativePath}/session.json`, Buffer.from(`${JSON.stringify({
+            recording_id: state.record.recordingId,
+            backend: state.record.backend,
+            session_id: state.record.sessionId,
+            session_label: state.session.label || state.session.sessionId,
+            instance_id: state.record.instanceId,
+            tab_id: state.record.tabId,
+            ...(state.record.tabTitle ? { tab_title: state.record.tabTitle } : {}),
+            ...(state.record.tabUrl ? { tab_url: state.record.tabUrl } : {}),
+            started_at: state.record.startedAt,
+            ...(state.record.stoppedAt
+                ? { stopped_at: state.record.stoppedAt }
+                : {}),
+            status: state.record.status,
+            event_count: state.record.eventCount,
+            ...(state.record.lastEventAt
+                ? { last_event_at: state.record.lastEventAt }
+                : {}),
+            bundle_dir_name: state.record.bundleDirName,
+            bundle_relative_path: state.record.bundleRelativePath,
+            bundle_path: state.record.bundlePath,
+            current_page_id: state.currentPageId,
+            current_page_url: state.currentPageUrl,
+            files: {
+                timeline: "timeline.ndjson",
+                session: "session.json",
+                pages: "pages",
+                network: "network",
+                network_index: "network/index.ndjson",
+                network_requests: "network/requests",
+                console: "console",
+            },
+        }, null, 2)}\n`, "utf8"));
+    }
+    buildSummary(event) {
+        switch (event.kind) {
+            case "console_event":
+                return `${event.level || "log"} ${event.text || ""}`.trim();
+            case "page_snapshot":
+                return `${event.reason || "snapshot"} ${event.title || event.url || ""}`.trim();
+            case "network_request":
+                return `${event.method || "GET"} ${event.url || ""}`.trim();
+            case "network_response_complete":
+                return `${event.status_code || 0} ${event.url || ""}`.trim();
+            case "network_error":
+                return `${event.error || "error"} ${event.url || ""}`.trim();
+            case "navigation":
+                return `${event.status || "navigation"} ${event.url || ""}`.trim();
+            case "session_started":
+            case "session_stopped":
+                return event.kind;
+            default:
+                return event.kind;
+        }
+    }
+}
+exports.BrowserRecordingBundleWriter = BrowserRecordingBundleWriter;

package/dist/services/features/telegram-mcp/src/features/browser-attach/model/firefoxAttachRegistry.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirefoxAttachRegistry = void 0;
+const localTimestamp_1 = require("../../../shared/lib/time/localTimestamp");
+class FirefoxAttachRegistry {
+    instances = new Map();
+    setConnected(input) {
+        const now = (0, localTimestamp_1.formatLocalTimestamp)(new Date());
+        const existing = this.instances.get(input.instanceId);
+        const next = {
+            instanceId: input.instanceId,
+            browser: input.browser,
+            extensionVersion: input.extensionVersion,
+            ...(input.profileName ? { profileName: input.profileName } : {}),
+            connectedAt: existing?.connectedAt ?? now,
+            lastSeenAt: now,
+            capabilities: [...input.capabilities],
+            tabs: existing?.tabs ?? [],
+            activeTab: existing?.activeTab ?? null,
+        };
+        this.instances.set(input.instanceId, next);
+        return next;
+    }
+    touch(instanceId) {
+        const existing = this.instances.get(instanceId);
+        if (!existing) {
+            return;
+        }
+        existing.lastSeenAt = (0, localTimestamp_1.formatLocalTimestamp)(new Date());
+    }
+    setTabs(instanceId, tabs) {
+        const existing = this.instances.get(instanceId);
+        if (!existing) {
+            return;
+        }
+        existing.tabs = tabs.map((tab) => ({ ...tab }));
+        existing.activeTab =
+            tabs.find((tab) => tab.active) ?? existing.activeTab ?? null;
+        existing.lastSeenAt = (0, localTimestamp_1.formatLocalTimestamp)(new Date());
+    }
+    setActiveTab(instanceId, tab) {
+        const existing = this.instances.get(instanceId);
+        if (!existing) {
+            return;
+        }
+        existing.activeTab = tab ? { ...tab } : null;
+        existing.lastSeenAt = (0, localTimestamp_1.formatLocalTimestamp)(new Date());
+    }
+    updateTab(instanceId, tab) {
+        const existing = this.instances.get(instanceId);
+        if (!existing) {
+            return;
+        }
+        const nextTabs = [...existing.tabs];
+        const index = nextTabs.findIndex((item) => item.tab_id === tab.tab_id);
+        if (index >= 0) {
+            nextTabs[index] = { ...nextTabs[index], ...tab };
+        }
+        else {
+            nextTabs.push({ ...tab });
+        }
+        existing.tabs = nextTabs;
+        if (tab.active) {
+            existing.activeTab = { ...tab };
+        }
+        existing.lastSeenAt = (0, localTimestamp_1.formatLocalTimestamp)(new Date());
+    }
+    remove(instanceId) {
+        this.instances.delete(instanceId);
+    }
+    listInstances() {
+        return Array.from(this.instances.values()).map((item) => ({
+            ...item,
+            tabs: item.tabs.map((tab) => ({ ...tab })),
+            activeTab: item.activeTab ? { ...item.activeTab } : null,
+            capabilities: [...item.capabilities],
+        }));
+    }
+}
+exports.FirefoxAttachRegistry = FirefoxAttachRegistry;