@deadragdoll/tellymcp 0.0.12 → 0.0.14

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

@@ -0,0 +1,736 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirefoxAttachServer = void 0;
+const node_crypto_1 = require("node:crypto");
+const wsModule = __importStar(require("ws"));
+const localTimestamp_1 = require("../../../shared/lib/time/localTimestamp");
+const bodyLimits_1 = require("../../../shared/lib/bodyLimits");
+const browserRecordingBundle_1 = require("./browserRecordingBundle");
+const firefoxAttachRegistry_1 = require("./firefoxAttachRegistry");
+const types_1 = require("./types");
+const wsLib = wsModule;
+const WebSocketServer = wsLib.WebSocketServer;
+const WS_OPEN = wsLib.WebSocket.OPEN;
+const ATTACH_HEARTBEAT_TIMEOUT_MS = 45_000;
+const ATTACH_HEARTBEAT_REAP_INTERVAL_MS = 15_000;
+const ATTACH_RATE_WINDOW_MS = 1_000;
+const ATTACH_RATE_MAX_MESSAGES = 1_000;
+class FirefoxAttachProtocolError extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+        this.name = "FirefoxAttachProtocolError";
+    }
+}
+const isAllowedAttachOrigin = (origin) => {
+    if (!origin) {
+        return false;
+    }
+    return /^(?:moz|chrome)-extension:\/\/[a-z0-9-]+\/?$/iu.test(origin);
+};
+class FirefoxAttachServer {
+    config;
+    logger;
+    sessionStore;
+    maintenanceStore;
+    wsServer = null;
+    registry = new firefoxAttachRegistry_1.FirefoxAttachRegistry();
+    recordingWriter;
+    sockets = new Set();
+    socketsByInstanceId = new Map();
+    pendingTabActions = new Map();
+    pendingRecordingControls = new Map();
+    activeRecordingsById = new Map();
+    heartbeatReaper = null;
+    constructor(config, logger, sessionStore, maintenanceStore) {
+        this.config = config;
+        this.logger = logger;
+        this.sessionStore = sessionStore;
+        this.maintenanceStore = maintenanceStore;
+        this.recordingWriter = new browserRecordingBundle_1.BrowserRecordingBundleWriter(config, logger);
+    }
+    async start() {
+        if (!this.config.browser.attach.enabled) {
+            return;
+        }
+        if (this.wsServer) {
+            return;
+        }
+        const wsServer = new WebSocketServer({
+            host: this.config.browser.attach.host,
+            port: this.config.browser.attach.port,
+            path: this.config.browser.attach.path,
+            maxPayload: bodyLimits_1.MAX_BODY_SIZE_BYTES,
+            verifyClient: (info, done) => {
+                if (!isAllowedAttachOrigin(info.origin)) {
+                    done(false, 403, "Forbidden");
+                    return;
+                }
+                done(true);
+            },
+        });
+        this.wsServer = wsServer;
+        wsServer.on("connection", (socket) => {
+            const now = Date.now();
+            const state = {
+                socket,
+                lastSeenAt: now,
+                rateWindowStartedAt: now,
+                rateWindowMessageCount: 0,
+                protocolFailed: false,
+            };
+            this.sockets.add(state);
+            socket.on("message", (payload) => {
+                void this.handleMessage(state, payload).catch((error) => {
+                    this.handleProtocolError(state, error);
+                });
+            });
+            socket.on("close", () => {
+                if (state.instanceId) {
+                    const current = this.socketsByInstanceId.get(state.instanceId);
+                    if (current === state) {
+                        void this.handleInstanceDisconnect(state.instanceId).catch((error) => {
+                            this.logger.error("Firefox attach disconnect cleanup failed", {
+                                instanceId: state.instanceId,
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        });
+                        this.registry.remove(state.instanceId);
+                        this.socketsByInstanceId.delete(state.instanceId);
+                    }
+                    this.logger.info("Firefox attach instance disconnected", {
+                        instanceId: state.instanceId,
+                    });
+                }
+                this.sockets.delete(state);
+            });
+            socket.on("error", (error) => {
+                this.logger.debug("Firefox attach socket error", {
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
+            });
+        });
+        this.heartbeatReaper = setInterval(() => {
+            this.reapStaleSockets();
+        }, ATTACH_HEARTBEAT_REAP_INTERVAL_MS);
+        this.heartbeatReaper.unref();
+        this.logger.info("Firefox attach WebSocket server started", {
+            host: this.config.browser.attach.host,
+            port: this.config.browser.attach.port,
+            path: this.config.browser.attach.path,
+        });
+    }
+    async stop() {
+        if (!this.wsServer) {
+            return;
+        }
+        if (this.heartbeatReaper) {
+            clearInterval(this.heartbeatReaper);
+            this.heartbeatReaper = null;
+        }
+        for (const state of this.sockets) {
+            try {
+                state.socket.close(1001, "server shutdown");
+            }
+            catch {
+                // ignore
+            }
+        }
+        this.sockets.clear();
+        this.socketsByInstanceId.clear();
+        const wsServer = this.wsServer;
+        this.wsServer = null;
+        await new Promise((resolve, reject) => {
+            wsServer.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+        this.logger.info("Firefox attach WebSocket server stopped");
+    }
+    listInstances() {
+        return this.registry.listInstances();
+    }
+    async getRecordingStatus(sessionId) {
+        return this.maintenanceStore.getBrowserRecording(sessionId);
+    }
+    async startRecording(input) {
+        const existing = await this.maintenanceStore.getBrowserRecording(input.sessionId);
+        if (existing?.status === "recording") {
+            if (existing.instanceId !== input.instanceId) {
+                throw new Error("Recording is already active in another browser instance.");
+            }
+            if (existing.tabId !== input.tabId) {
+                throw new Error(`Browser instance '${input.instanceId}' is already recording tab '${existing.tabId}'. Stop it before starting recording for tab '${input.tabId}'.`);
+            }
+            return existing;
+        }
+        const session = await this.sessionStore.getSession(input.sessionId);
+        const resolvedSession = session ||
+            {
+                sessionId: input.sessionId,
+                label: this.config.project.sessionLabel?.trim() || input.sessionId,
+                cwd: process.cwd(),
+                updatedAt: (0, localTimestamp_1.formatLocalTimestamp)(new Date()),
+            };
+        if (!resolvedSession.cwd?.trim()) {
+            throw new Error("Workspace cwd is not registered for this console.");
+        }
+        if (!session) {
+            await this.sessionStore.setSession({
+                sessionId: resolvedSession.sessionId,
+                ...(resolvedSession.label ? { label: resolvedSession.label } : {}),
+                cwd: resolvedSession.cwd,
+                updatedAt: resolvedSession.updatedAt,
+            });
+            this.logger.info("Firefox attach recording synthesized missing session context", {
+                sessionId: input.sessionId,
+                cwd: resolvedSession.cwd,
+                label: resolvedSession.label,
+            });
+        }
+        const recordingId = (0, node_crypto_1.randomUUID)();
+        const state = await this.recordingWriter.create({
+            session: resolvedSession,
+            sessionId: input.sessionId,
+            instanceId: input.instanceId,
+            tabId: input.tabId,
+            tabTitle: input.tabTitle,
+            ...(input.tabUrl ? { tabUrl: input.tabUrl } : {}),
+            recordingId,
+        });
+        this.activeRecordingsById.set(recordingId, state);
+        await this.maintenanceStore.setBrowserRecording(state.record);
+        await this.broadcastRecordingState(state.record);
+        try {
+            await this.invokeRecordingControl({
+                instanceId: input.instanceId,
+                tabId: input.tabId,
+                recordingId,
+                mode: "start",
+            });
+        }
+        catch (error) {
+            this.activeRecordingsById.delete(recordingId);
+            await this.maintenanceStore.clearBrowserRecording(input.sessionId);
+            await this.broadcastRecordingState(null);
+            throw error;
+        }
+        return state.record;
+    }
+    async stopRecording(input) {
+        const existing = await this.maintenanceStore.getBrowserRecording(input.sessionId);
+        if (!existing) {
+            return null;
+        }
+        const socketState = this.socketsByInstanceId.get(existing.instanceId);
+        const activeState = this.activeRecordingsById.get(existing.recordingId);
+        if (socketState) {
+            try {
+                await this.invokeRecordingControl({
+                    instanceId: existing.instanceId,
+                    tabId: existing.tabId,
+                    recordingId: existing.recordingId,
+                    mode: "stop",
+                });
+            }
+            catch {
+                // Local writer or persisted state still finalizes the bundle.
+            }
+        }
+        if (activeState) {
+            await this.recordingWriter.appendEvent(activeState, {
+                kind: "session_stopped",
+                status: "stopped",
+            });
+            this.activeRecordingsById.delete(existing.recordingId);
+            await this.maintenanceStore.setBrowserRecording(activeState.record);
+            await this.broadcastRecordingState(activeState.record);
+            return activeState.record;
+        }
+        if (existing.status !== "stopped") {
+            const session = await this.sessionStore.getSession(existing.sessionId);
+            const stopped = session?.cwd?.trim()
+                ? await this.recordingWriter.finalizeExisting({
+                    session,
+                    record: existing,
+                })
+                : {
+                    ...existing,
+                    status: "stopped",
+                    stoppedAt: (0, localTimestamp_1.formatLocalTimestamp)(new Date()),
+                };
+            await this.maintenanceStore.setBrowserRecording(stopped);
+            await this.broadcastRecordingState(stopped);
+            return stopped;
+        }
+        return existing;
+    }
+    async invokeTabAction(input) {
+        const socketState = this.socketsByInstanceId.get(input.instanceId);
+        if (!socketState) {
+            throw new Error(`Attached browser instance '${input.instanceId}' is not connected.`);
+        }
+        const requestId = `tab-action-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+        const result = await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingTabActions.delete(requestId);
+                reject(new Error(`Attached browser action '${input.action}' timed out for instance '${input.instanceId}'.`));
+            }, this.config.browser.timeoutMs);
+            this.pendingTabActions.set(requestId, {
+                instanceId: input.instanceId,
+                resolve,
+                reject,
+                timer,
+            });
+            this.sendJson(socketState.socket, {
+                type: "tab_action",
+                request_id: requestId,
+                tab_id: input.tabId,
+                action: input.action,
+                ...(input.payload ? { payload: input.payload } : {}),
+            });
+        });
+        if (!result.ok) {
+            throw new Error(result.error ||
+                `Attached browser action '${input.action}' failed for instance '${input.instanceId}'.`);
+        }
+        return result.result;
+    }
+    sendJson(socket, payload) {
+        if (socket.readyState !== WS_OPEN) {
+            return;
+        }
+        socket.send(JSON.stringify(payload));
+    }
+    async handleMessage(state, payload) {
+        if (state.protocolFailed) {
+            return;
+        }
+        this.enforceRateLimit(state);
+        state.lastSeenAt = Date.now();
+        const raw = typeof payload === "string"
+            ? payload
+            : Buffer.isBuffer(payload)
+                ? payload.toString("utf8")
+                : payload instanceof ArrayBuffer
+                    ? Buffer.from(payload).toString("utf8")
+                    : Array.isArray(payload) && payload.every(Buffer.isBuffer)
+                        ? Buffer.concat(payload).toString("utf8")
+                        : String(payload ?? "");
+        let decoded;
+        try {
+            decoded = JSON.parse(raw);
+        }
+        catch {
+            throw new FirefoxAttachProtocolError("invalid_json");
+        }
+        const parsed = types_1.firefoxAttachInboundMessageSchema.safeParse(decoded);
+        if (!parsed.success) {
+            throw new FirefoxAttachProtocolError("invalid_message");
+        }
+        const message = parsed.data;
+        if (!state.instanceId && message.type !== "hello") {
+            throw new FirefoxAttachProtocolError("hello_required");
+        }
+        if (state.instanceId && message.type === "hello") {
+            throw new FirefoxAttachProtocolError("duplicate_hello");
+        }
+        const connectedInstanceId = state.instanceId;
+        switch (message.type) {
+            case "hello":
+                await this.handleHello(state, message);
+                return;
+            case "heartbeat":
+                if (state.instanceId) {
+                    this.registry.touch(state.instanceId);
+                }
+                return;
+            case "list_tabs_result":
+                if (state.instanceId) {
+                    this.registry.setTabs(state.instanceId, message.tabs);
+                }
+                return;
+            case "get_active_tab_result":
+                if (state.instanceId) {
+                    this.registry.setActiveTab(state.instanceId, message.tab);
+                }
+                return;
+            case "active_tab_changed":
+                if (state.instanceId) {
+                    this.registry.setActiveTab(state.instanceId, message.tab);
+                }
+                return;
+            case "tab_updated":
+                if (state.instanceId) {
+                    this.registry.updateTab(state.instanceId, message.tab);
+                }
+                return;
+            case "attach_tab_selected":
+                if (state.instanceId) {
+                    this.registry.updateTab(state.instanceId, {
+                        ...message.tab,
+                        active: true,
+                    });
+                    await this.persistSelectedTab(state.instanceId, message.tab);
+                }
+                return;
+            case "tab_action_result":
+                if (connectedInstanceId) {
+                    this.resolvePendingTabAction(connectedInstanceId, message);
+                }
+                return;
+            case "recording_control_result":
+                if (connectedInstanceId) {
+                    this.resolvePendingRecordingControl(connectedInstanceId, message);
+                }
+                return;
+            case "recording_event":
+                if (state.instanceId) {
+                    await this.handleRecordingEvent(state.instanceId, message.recording_id, message.tab_id, message.event);
+                }
+                return;
+            case "recording_manual_start":
+            case "recording_manual_stop":
+            case "recording_manual_status":
+                if (state.instanceId) {
+                    await this.handleManualRecordingRequest(state.socket, state.instanceId, message);
+                }
+                return;
+            default:
+                return;
+        }
+    }
+    async handleHello(state, message) {
+        const previous = this.socketsByInstanceId.get(message.instance_id);
+        state.instanceId = message.instance_id;
+        this.socketsByInstanceId.set(message.instance_id, state);
+        if (previous && previous !== state) {
+            this.logger.warn("Firefox attach instance connection replaced", {
+                instanceId: message.instance_id,
+            });
+            previous.socket.close(4001, "replaced by newer connection");
+        }
+        const instance = this.registry.setConnected({
+            instanceId: message.instance_id,
+            browser: message.browser,
+            extensionVersion: message.extension_version,
+            ...(message.profile_name ? { profileName: message.profile_name } : {}),
+            capabilities: ["tabs", "active_tab", "recording"],
+        });
+        this.sendJson(state.socket, {
+            type: "hello_ack",
+            ok: true,
+            instance_id: message.instance_id,
+            capabilities: instance.capabilities,
+            ...(this.config.project.sessionId
+                ? { session_id: this.config.project.sessionId }
+                : {}),
+            ...(this.config.project.sessionLabel
+                ? { session_label: this.config.project.sessionLabel }
+                : {}),
+        });
+        this.logger.info("Firefox attach instance connected", {
+            instanceId: message.instance_id,
+            extensionVersion: message.extension_version,
+            profileName: message.profile_name,
+        });
+        this.sendJson(state.socket, {
+            type: "list_tabs",
+            request_id: "bootstrap-list-tabs",
+        });
+        this.sendJson(state.socket, {
+            type: "get_active_tab",
+            request_id: "bootstrap-active-tab",
+        });
+        await this.sendCurrentRecordingState(state.socket);
+    }
+    async persistSelectedTab(instanceId, tab) {
+        const sessionId = this.config.project.sessionId?.trim();
+        if (!sessionId) {
+            return;
+        }
+        await this.maintenanceStore.setBrowserAttachment({
+            sessionId,
+            backend: "firefox-attached",
+            instanceId,
+            tabId: tab.tab_id,
+            attachedAt: (0, localTimestamp_1.formatLocalTimestamp)(new Date()),
+            ...(tab.title ? { title: tab.title } : {}),
+            ...(tab.url ? { url: tab.url } : {}),
+        });
+        this.logger.info("Firefox attached tab selected", {
+            sessionId,
+            instanceId,
+            tabId: tab.tab_id,
+            title: tab.title,
+            url: tab.url,
+        });
+    }
+    resolvePendingTabAction(instanceId, message) {
+        const pending = this.pendingTabActions.get(message.request_id);
+        if (!pending || pending.instanceId !== instanceId) {
+            return;
+        }
+        clearTimeout(pending.timer);
+        this.pendingTabActions.delete(message.request_id);
+        pending.resolve(message);
+    }
+    resolvePendingRecordingControl(instanceId, message) {
+        const pending = this.pendingRecordingControls.get(message.request_id);
+        if (!pending || pending.instanceId !== instanceId) {
+            return;
+        }
+        clearTimeout(pending.timer);
+        this.pendingRecordingControls.delete(message.request_id);
+        pending.resolve(message);
+    }
+    async invokeRecordingControl(input) {
+        const socketState = this.socketsByInstanceId.get(input.instanceId);
+        if (!socketState) {
+            throw new Error(`Attached browser instance '${input.instanceId}' is not connected.`);
+        }
+        const requestId = `recording-${input.mode}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+        const result = await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRecordingControls.delete(requestId);
+                reject(new Error(`Attached browser recording '${input.mode}' timed out for instance '${input.instanceId}'.`));
+            }, this.config.browser.timeoutMs);
+            this.pendingRecordingControls.set(requestId, {
+                instanceId: input.instanceId,
+                resolve,
+                reject,
+                timer,
+            });
+            this.sendJson(socketState.socket, input.mode === "start"
+                ? {
+                    type: "recording_start",
+                    request_id: requestId,
+                    recording_id: input.recordingId,
+                    tab_id: input.tabId,
+                }
+                : {
+                    type: "recording_stop",
+                    request_id: requestId,
+                    recording_id: input.recordingId,
+                    tab_id: input.tabId,
+                });
+        });
+        if (!result.ok) {
+            throw new Error(result.error ||
+                `Attached browser recording '${input.mode}' failed for instance '${input.instanceId}'.`);
+        }
+    }
+    async handleRecordingEvent(instanceId, recordingId, tabId, event) {
+        const state = this.activeRecordingsById.get(recordingId);
+        if (!state) {
+            return;
+        }
+        if (state.record.instanceId !== instanceId || state.record.tabId !== tabId) {
+            return;
+        }
+        await this.recordingWriter.appendEvent(state, event);
+        await this.maintenanceStore.setBrowserRecording(state.record);
+    }
+    async handleInstanceDisconnect(instanceId) {
+        const activeStates = Array.from(this.activeRecordingsById.values()).filter((state) => state.record.instanceId === instanceId);
+        if (activeStates.length === 0) {
+            return;
+        }
+        for (const state of activeStates) {
+            await this.recordingWriter.appendEvent(state, {
+                kind: "session_stopped",
+                status: "instance_disconnected",
+            });
+            this.activeRecordingsById.delete(state.record.recordingId);
+            await this.maintenanceStore.setBrowserRecording(state.record);
+            await this.broadcastRecordingState(state.record);
+        }
+    }
+    buildRecordingStateMessage(record) {
+        return {
+            type: "recording_state",
+            active: record?.status === "recording",
+            ...(record ? { recording: this.mapManualRecordingResult(record) } : {}),
+        };
+    }
+    async sendCurrentRecordingState(socket) {
+        const sessionId = this.config.project.sessionId?.trim();
+        const record = sessionId
+            ? await this.maintenanceStore.getBrowserRecording(sessionId)
+            : null;
+        this.sendJson(socket, this.buildRecordingStateMessage(record));
+    }
+    async broadcastRecordingState(record) {
+        const payload = this.buildRecordingStateMessage(record);
+        for (const state of this.sockets) {
+            if (state.instanceId) {
+                this.sendJson(state.socket, payload);
+            }
+        }
+    }
+    enforceRateLimit(state) {
+        const now = Date.now();
+        if (now - state.rateWindowStartedAt >= ATTACH_RATE_WINDOW_MS) {
+            state.rateWindowStartedAt = now;
+            state.rateWindowMessageCount = 0;
+        }
+        state.rateWindowMessageCount += 1;
+        if (state.rateWindowMessageCount > ATTACH_RATE_MAX_MESSAGES) {
+            throw new FirefoxAttachProtocolError("rate_limit_exceeded");
+        }
+    }
+    handleProtocolError(state, error) {
+        if (state.protocolFailed) {
+            return;
+        }
+        state.protocolFailed = true;
+        const reason = error instanceof FirefoxAttachProtocolError
+            ? error.reason
+            : "message_handler_failed";
+        this.logger.warn("Firefox attach protocol error", {
+            ...(state.instanceId ? { instanceId: state.instanceId } : {}),
+            reason,
+        });
+        try {
+            state.socket.close(1008, reason);
+        }
+        catch {
+            // The socket may already have closed while the handler was awaiting I/O.
+        }
+    }
+    reapStaleSockets() {
+        const staleBefore = Date.now() - ATTACH_HEARTBEAT_TIMEOUT_MS;
+        for (const state of this.sockets) {
+            if (state.lastSeenAt >= staleBefore) {
+                continue;
+            }
+            this.logger.warn("Firefox attach socket heartbeat expired", {
+                ...(state.instanceId ? { instanceId: state.instanceId } : {}),
+            });
+            state.socket.close(4002, "heartbeat timeout");
+        }
+    }
+    mapManualRecordingResult(record) {
+        if (!record) {
+            return undefined;
+        }
+        return {
+            recording_id: record.recordingId,
+            instance_id: record.instanceId,
+            tab_id: record.tabId,
+            ...(record.tabTitle ? { tab_title: record.tabTitle } : {}),
+            ...(record.tabUrl ? { tab_url: record.tabUrl } : {}),
+            bundle_dir_name: record.bundleDirName,
+            bundle_relative_path: record.bundleRelativePath,
+            bundle_path: record.bundlePath,
+            started_at: record.startedAt,
+            ...(record.stoppedAt ? { stopped_at: record.stoppedAt } : {}),
+            status: record.status,
+            event_count: record.eventCount,
+            ...(record.lastEventAt ? { last_event_at: record.lastEventAt } : {}),
+        };
+    }
+    async handleManualRecordingRequest(socket, instanceId, message) {
+        const sessionId = this.config.project.sessionId?.trim();
+        if (!sessionId) {
+            this.sendJson(socket, {
+                type: "recording_manual_result",
+                request_id: message.request_id,
+                ok: false,
+                active: false,
+                error: "Session id is not configured for this attach server.",
+            });
+            return;
+        }
+        try {
+            if (message.type === "recording_manual_status") {
+                const record = await this.getRecordingStatus(sessionId);
+                this.sendJson(socket, {
+                    type: "recording_manual_result",
+                    request_id: message.request_id,
+                    ok: true,
+                    active: record?.status === "recording",
+                    ...(record ? { recording: this.mapManualRecordingResult(record) } : {}),
+                });
+                return;
+            }
+            if (message.type === "recording_manual_stop") {
+                const record = await this.stopRecording({ sessionId });
+                this.sendJson(socket, {
+                    type: "recording_manual_result",
+                    request_id: message.request_id,
+                    ok: true,
+                    active: record?.status === "recording",
+                    ...(record ? { recording: this.mapManualRecordingResult(record) } : {}),
+                });
+                return;
+            }
+            const tab = message.tab;
+            if (!tab) {
+                throw new Error("Selected tab metadata is required to start recording.");
+            }
+            const record = await this.startRecording({
+                sessionId,
+                instanceId,
+                tabId: tab.tab_id,
+                tabTitle: tab.title || "attached-tab",
+                ...(tab.url ? { tabUrl: tab.url } : {}),
+            });
+            this.sendJson(socket, {
+                type: "recording_manual_result",
+                request_id: message.request_id,
+                ok: true,
+                active: true,
+                recording: this.mapManualRecordingResult(record),
+            });
+        }
+        catch (error) {
+            this.sendJson(socket, {
+                type: "recording_manual_result",
+                request_id: message.request_id,
+                ok: false,
+                active: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+}
+exports.FirefoxAttachServer = FirefoxAttachServer;