@deadragdoll/tellymcp 0.0.11 → 0.0.13

package/packages/chrome-attach-extension/dist/popup.js

@@ -0,0 +1,79 @@
+const browser = globalThis.browser ?? globalThis.chrome;
+
+const DEFAULT_CONNECTION_STATUS = {
+  state: "disconnected",
+  text: "Disconnected",
+};
+
+const ATTACHED_TAB_KEY = "attach_selected_tab";
+
+function storageGet(defaults) {
+  return new Promise((resolve, reject) => {
+    browser.storage.local.get(defaults, (result) => {
+      const error = browser.runtime?.lastError;
+      if (error) {
+        reject(new Error(error.message));
+        return;
+      }
+      resolve(result);
+    });
+  });
+}
+
+function setStatus(state, text) {
+  const node = document.getElementById("connection-status");
+  if (!node) {
+    return;
+  }
+  node.textContent = text;
+  node.style.color =
+    state === "connected"
+      ? "var(--accent)"
+      : state === "connecting"
+        ? "var(--warn)"
+        : "var(--soft)";
+}
+
+function setText(id, text) {
+  const node = document.getElementById(id);
+  if (!node) {
+    return;
+  }
+  node.textContent = text;
+}
+
+async function render() {
+  const stored = await storageGet({
+    attach_connection_status: DEFAULT_CONNECTION_STATUS,
+    [ATTACHED_TAB_KEY]: null,
+  });
+  const status = stored.attach_connection_status ?? DEFAULT_CONNECTION_STATUS;
+  setStatus(status.state, status.text || DEFAULT_CONNECTION_STATUS.text);
+  setText(
+    "session",
+    `Session: ${status.session_label || status.session_id || "-"}`,
+  );
+  setText(
+    "attached-tab",
+    stored[ATTACHED_TAB_KEY]?.title
+      ? `Attached: ${stored[ATTACHED_TAB_KEY].title}`
+      : "Attached: -",
+  );
+}
+
+document.getElementById("open-settings").addEventListener("click", () => {
+  void browser.tabs.create({
+    url: browser.runtime.getURL("options.html"),
+  });
+});
+
+browser.storage.onChanged.addListener((changes, areaName) => {
+  if (areaName !== "local") {
+    return;
+  }
+  if (changes.attach_connection_status || changes[ATTACHED_TAB_KEY]) {
+    void render();
+  }
+});
+
+void render();

package/packages/chrome-attach-extension/dist/recorder-content.js

@@ -0,0 +1,83 @@
+(() => {
+  const browser = globalThis.browser ?? globalThis.chrome;
+
+  function sendRuntimeMessage(message) {
+    return new Promise((resolve, reject) => {
+      browser.runtime.sendMessage(message, (response) => {
+        const error = browser.runtime?.lastError;
+        if (error) {
+          reject(new Error(error.message));
+          return;
+        }
+        resolve(response);
+      });
+    });
+  }
+
+  if (window.__tellyRecorderContentInstalled === true) {
+    return;
+  }
+  window.__tellyRecorderContentInstalled = true;
+
+  function emit(payload) {
+    void sendRuntimeMessage({
+      type: "telly_recording_page_event",
+      event: payload,
+    }).catch(() => {});
+  }
+
+  function snapshot(reason) {
+    emit({
+      kind: "page_snapshot",
+      source: "content",
+      reason,
+      at: new Date().toISOString(),
+      url: location.href,
+      title: document.title,
+      ready_state: document.readyState,
+      html: document.documentElement?.outerHTML || "",
+    });
+  }
+
+  window.addEventListener("message", (event) => {
+    if (event.source !== window) {
+      return;
+    }
+    if (!event.data || event.data.__tellyRecorderPageEvent !== true) {
+      return;
+    }
+    emit(event.data.payload);
+  });
+
+  const injection = document.createElement("script");
+  injection.src = browser.runtime.getURL("recorder-page.js");
+  injection.async = false;
+  (document.documentElement || document.head || document.body).appendChild(injection);
+  injection.addEventListener(
+    "load",
+    () => {
+      injection.remove();
+    },
+    { once: true },
+  );
+  injection.addEventListener(
+    "error",
+    () => {
+      emit({
+        kind: "console_event",
+        source: "content",
+        level: "error",
+        text: "Failed to load recorder-page.js",
+        url: location.href,
+        title: document.title,
+      });
+      injection.remove();
+    },
+    { once: true },
+  );
+
+  snapshot("recording-script-installed");
+  window.addEventListener("load", () => {
+    snapshot("window-load");
+  });
+})();

package/packages/chrome-attach-extension/dist/recorder-page.js

@@ -0,0 +1,266 @@
+(() => {
+  if (window.__tellyRecorderPageInstalled === true) {
+    return;
+  }
+  window.__tellyRecorderPageInstalled = true;
+
+  const MAX_TEXT_CHARS = 64 * 1024;
+  const truncateText = (value) => {
+    const text = String(value ?? "");
+    return text.length > MAX_TEXT_CHARS ? text.slice(0, MAX_TEXT_CHARS) : text;
+  };
+  const serializeValue = (value, depth = 0) => {
+    if (depth >= 2) return truncateText(value);
+    if (value === null || value === undefined) return value;
+    if (typeof value === "string") return truncateText(value);
+    if (typeof value === "number" || typeof value === "boolean") return value;
+    if (value instanceof Error) {
+      return {
+        name: value.name,
+        message: truncateText(value.message),
+        stack: truncateText(value.stack || ""),
+      };
+    }
+    if (Array.isArray(value)) {
+      return value.slice(0, 20).map((item) => serializeValue(item, depth + 1));
+    }
+    if (typeof value === "object") {
+      const output = {};
+      for (const [key, nested] of Object.entries(value).slice(0, 20)) {
+        output[key] = serializeValue(nested, depth + 1);
+      }
+      return output;
+    }
+    return truncateText(value);
+  };
+  const emit = (payload) => {
+    window.postMessage({ __tellyRecorderPageEvent: true, payload }, "*");
+  };
+  const headersToArray = (headers) => {
+    try {
+      return Array.from(headers.entries()).map(([name, value]) => ({ name, value }));
+    } catch {
+      return [];
+    }
+  };
+  const serializeRequestBody = async (request) => {
+    try {
+      const text = await request.clone().text();
+      if (!text) return { body_text: "" };
+      return {
+        body_text: truncateText(text),
+        body_truncated: text.length > MAX_TEXT_CHARS,
+      };
+    } catch {
+      return {};
+    }
+  };
+
+  for (const level of ["log", "info", "warn", "error", "debug"]) {
+    const original = console[level];
+    console[level] = function patchedConsole(...args) {
+      try {
+        emit({
+          kind: "console_event",
+          source: "page",
+          at: new Date().toISOString(),
+          level,
+          text: truncateText(
+            args
+              .map((item) => {
+                if (typeof item === "string") return item;
+                try {
+                  return JSON.stringify(item);
+                } catch {
+                  return String(item);
+                }
+              })
+              .join(" "),
+          ),
+          args: args.map((item) => serializeValue(item)),
+          url: location.href,
+          title: document.title,
+        });
+      } catch {
+        // ignore
+      }
+      return original.apply(this, args);
+    };
+  }
+
+  window.addEventListener("error", (event) => {
+    emit({
+      kind: "console_event",
+      source: "page",
+      at: new Date().toISOString(),
+      level: "error",
+      text: truncateText(event.message || "window error"),
+      args: [
+        {
+          filename: event.filename || "",
+          lineno: event.lineno || 0,
+          colno: event.colno || 0,
+        },
+      ],
+      url: location.href,
+      title: document.title,
+    });
+  });
+
+  window.addEventListener("unhandledrejection", (event) => {
+    emit({
+      kind: "console_event",
+      source: "page",
+      at: new Date().toISOString(),
+      level: "error",
+      text: "Unhandled promise rejection",
+      args: [serializeValue(event.reason)],
+      url: location.href,
+      title: document.title,
+    });
+  });
+
+  const originalFetch = window.fetch.bind(window);
+  window.fetch = async (...args) => {
+    const startedAt = new Date().toISOString();
+    const request = new Request(...args);
+    const requestId = `page-fetch-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+    const body = await serializeRequestBody(request);
+    emit({
+      kind: "network_request",
+      source: "page",
+      at: startedAt,
+      request_id: requestId,
+      url: request.url,
+      method: request.method,
+      resource_type: "fetch",
+      headers: headersToArray(request.headers),
+      ...body,
+    });
+
+    const response = await originalFetch(...args);
+    emit({
+      kind: "network_response_complete",
+      source: "page",
+      at: new Date().toISOString(),
+      request_id: requestId,
+      url: request.url,
+      method: request.method,
+      resource_type: "fetch",
+      status_code: response.status,
+      headers: headersToArray(response.headers),
+    });
+
+    try {
+      const bodyText = await response.clone().text();
+      emit({
+        kind: "network_response_body",
+        source: "page",
+        at: new Date().toISOString(),
+        request_id: requestId,
+        url: request.url,
+        body_text: truncateText(bodyText),
+        body_truncated: bodyText.length > MAX_TEXT_CHARS,
+      });
+    } catch {
+      // ignore
+    }
+
+    return response;
+  };
+
+  const originalOpen = XMLHttpRequest.prototype.open;
+  const originalSend = XMLHttpRequest.prototype.send;
+  const originalSetHeader = XMLHttpRequest.prototype.setRequestHeader;
+  XMLHttpRequest.prototype.open = function patchedOpen(method, url, async, user, password) {
+    this.__tellyRecorder = {
+      request_id: `page-xhr-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
+      method: String(method || "GET"),
+      url: String(url || ""),
+      headers: [],
+    };
+    return originalOpen.call(this, method, url, async, user, password);
+  };
+  XMLHttpRequest.prototype.setRequestHeader = function patchedSetHeader(name, value) {
+    if (this.__tellyRecorder?.headers) {
+      this.__tellyRecorder.headers.push({ name: String(name), value: String(value) });
+    }
+    return originalSetHeader.call(this, name, value);
+  };
+  XMLHttpRequest.prototype.send = function patchedSend(body) {
+    const startedAt = new Date().toISOString();
+    const meta = this.__tellyRecorder || {
+      request_id: `page-xhr-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
+      method: "GET",
+      url: "",
+      headers: [],
+    };
+    const bodyText =
+      typeof body === "string"
+        ? body
+        : body instanceof URLSearchParams
+          ? body.toString()
+          : body instanceof FormData
+            ? Array.from(body.entries())
+                .map(([k, v]) => `${String(k)}=${String(v)}`)
+                .join("&")
+            : "";
+    emit({
+      kind: "network_request",
+      source: "page",
+      at: startedAt,
+      request_id: meta.request_id,
+      url: meta.url,
+      method: meta.method,
+      resource_type: "xmlhttprequest",
+      headers: meta.headers,
+      body_text: truncateText(bodyText),
+      body_truncated: bodyText.length > MAX_TEXT_CHARS,
+    });
+
+    this.addEventListener(
+      "loadend",
+      () => {
+        const headersRaw = this.getAllResponseHeaders() || "";
+        const headers = headersRaw
+          .split(/\r?\n/)
+          .map((line) => line.trim())
+          .filter(Boolean)
+          .map((line) => {
+            const separatorIndex = line.indexOf(":");
+            return separatorIndex <= 0
+              ? { name: line, value: "" }
+              : {
+                  name: line.slice(0, separatorIndex).trim(),
+                  value: line.slice(separatorIndex + 1).trim(),
+                };
+          });
+        emit({
+          kind: "network_response_complete",
+          source: "page",
+          at: new Date().toISOString(),
+          request_id: meta.request_id,
+          url: meta.url,
+          method: meta.method,
+          resource_type: "xmlhttprequest",
+          status_code: this.status,
+          headers,
+        });
+        if (typeof this.responseText === "string") {
+          emit({
+            kind: "network_response_body",
+            source: "page",
+            at: new Date().toISOString(),
+            request_id: meta.request_id,
+            url: meta.url,
+            body_text: truncateText(this.responseText),
+            body_truncated: this.responseText.length > MAX_TEXT_CHARS,
+          });
+        }
+      },
+      { once: true },
+    );
+
+    return originalSend.call(this, body);
+  };
+})();

package/packages/firefox-attach-extension/README.md

@@ -0,0 +1,13 @@
+# TellyMCP Firefox Attach Extension
+
+Firefox extension that lets `telegram_mcp` attach to an already running user browser session through a local WebSocket bridge.
+
+Current scope of this package:
+
+- extension options for host / port
+- background WebSocket client
+- browser instance hello handshake
+- tab listing
+- active-tab reporting
+
+This package is intentionally separate from the main `@deadragdoll/tellymcp` runtime package.