@deadragdoll/tellymcp 0.0.12 → 0.0.13

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

@@ -0,0 +1,559 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirefoxAttachServer = void 0;
+const node_crypto_1 = require("node:crypto");
+const ws_1 = __importDefault(require("ws"));
+const browserRecordingBundle_1 = require("./browserRecordingBundle");
+const firefoxAttachRegistry_1 = require("./firefoxAttachRegistry");
+const wsLib = ws_1.default;
+const WebSocketServer = wsLib.WebSocketServer;
+const WS_OPEN = wsLib.OPEN;
+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();
+    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;
+        }
+        this.wsServer = new WebSocketServer({
+            host: this.config.browser.attach.host,
+            port: this.config.browser.attach.port,
+            path: this.config.browser.attach.path,
+        });
+        this.wsServer.on("connection", (socket) => {
+            const state = { socket };
+            this.sockets.add(state);
+            socket.on("message", (payload) => {
+                void this.handleMessage(state, payload);
+            });
+            socket.on("close", () => {
+                if (state.instanceId) {
+                    void this.handleInstanceDisconnect(state.instanceId);
+                    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.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;
+        }
+        for (const state of this.sockets) {
+            try {
+                state.socket.close(1001, "server shutdown");
+            }
+            catch {
+                // ignore
+            }
+        }
+        this.sockets.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.");
+            }
+            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: new Date().toISOString(),
+            };
+        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 activeState = this.activeRecordingsById.get(existing.recordingId);
+        if (activeState) {
+            try {
+                await this.invokeRecordingControl({
+                    instanceId: activeState.record.instanceId,
+                    tabId: activeState.record.tabId,
+                    recordingId: activeState.record.recordingId,
+                    mode: "stop",
+                });
+            }
+            catch {
+                // Local writer still finalizes the bundle.
+            }
+            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 stopped = {
+                ...existing,
+                status: "stopped",
+                stoppedAt: new Date().toISOString(),
+            };
+            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, {
+                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) {
+        const raw = typeof payload === "string"
+            ? payload
+            : Buffer.isBuffer(payload)
+                ? payload.toString("utf8")
+                : String(payload ?? "");
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch {
+            this.logger.debug("Firefox attach message ignored because it is not valid JSON");
+            return;
+        }
+        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":
+                this.resolvePendingTabAction(message);
+                return;
+            case "recording_control_result":
+                this.resolvePendingRecordingControl(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) {
+        state.instanceId = message.instance_id;
+        this.socketsByInstanceId.set(message.instance_id, state);
+        const instance = this.registry.setConnected({
+            instanceId: message.instance_id,
+            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: new Date().toISOString(),
+            ...(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(message) {
+        const pending = this.pendingTabActions.get(message.request_id);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timer);
+        this.pendingTabActions.delete(message.request_id);
+        pending.resolve(message);
+    }
+    resolvePendingRecordingControl(message) {
+        const pending = this.pendingRecordingControls.get(message.request_id);
+        if (!pending) {
+            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, {
+                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) {
+            this.sendJson(state.socket, payload);
+        }
+    }
+    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;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/features/telegram-mcp/src/shared/integrations/redis/stateStore.js

@@ -44,6 +44,12 @@ function adminAuthorizedMatchPattern() {
 function gatewayClientUuidKey() {
     return `${KEY_PREFIX}:gateway:client-uuid`;
 }
+function browserAttachmentKey(sessionId) {
+    return `${KEY_PREFIX}:browser-attachment:${sessionId}`;
+}
+function browserRecordingKey(sessionId) {
+    return `${KEY_PREFIX}:browser-recording:${sessionId}`;
+}
 function outgoingDeliveryNoticeKey(deliveryUuid) {
     return `${KEY_PREFIX}:gateway:outgoing-delivery:${deliveryUuid}`;
 }
@@ -103,6 +109,8 @@ class RedisStateStore {
         await this.clearXchangeFileMetas(sessionId);
         await this.clearProjectMenuViewStates(sessionId);
         await this.clearOutgoingDeliveryNoticesForSession(sessionId);
+        await this.clearBrowserAttachment(sessionId);
+        await this.clearBrowserRecording(sessionId);
         await this.sessionAdapter.delete(sessionKey(sessionId));
     }
     async createPairCode(record, ttlSeconds) {
@@ -340,6 +348,26 @@ class RedisStateStore {
     async setGatewayClientUuid(clientUuid) {
         await this.redis.set(gatewayClientUuidKey(), clientUuid);
     }
+    async getBrowserAttachment(sessionId) {
+        const raw = await this.redis.get(browserAttachmentKey(sessionId));
+        return parseJson(raw);
+    }
+    async setBrowserAttachment(record) {
+        await this.redis.set(browserAttachmentKey(record.sessionId), JSON.stringify(record));
+    }
+    async clearBrowserAttachment(sessionId) {
+        await this.redis.del(browserAttachmentKey(sessionId));
+    }
+    async getBrowserRecording(sessionId) {
+        const raw = await this.redis.get(browserRecordingKey(sessionId));
+        return parseJson(raw);
+    }
+    async setBrowserRecording(record) {
+        await this.redis.set(browserRecordingKey(record.sessionId), JSON.stringify(record));
+    }
+    async clearBrowserRecording(sessionId) {
+        await this.redis.del(browserRecordingKey(sessionId));
+    }
     async setProjectMenuViewState(state) {
         await this.redis.set(projectMenuViewStateKey(state.projectUuid, state.sessionId), JSON.stringify(state));
     }