@deadragdoll/tellymcp 0.0.12 → 0.0.13

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

@@ -0,0 +1,77 @@
+(() => {
+  if (window.__tellyRecorderContentInstalled === true) {
+    return;
+  }
+  window.__tellyRecorderContentInstalled = true;
+
+  function emit(payload) {
+    try {
+      browser.runtime.sendMessage({
+        type: "telly_recording_page_event",
+        event: payload,
+      });
+    } catch {
+      // ignore
+    }
+  }
+
+  function snapshot(reason) {
+    if (window.top !== window) {
+      return;
+    }
+    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");
+  if (window.top === window) {
+    window.addEventListener("load", () => {
+      snapshot("window-load");
+    });
+  }
+})();

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

@@ -0,0 +1,302 @@
+(() => {
+  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 emitConsole = (level, args, textOverride) => {
+    emit({
+      kind: "console_event",
+      source: "page",
+      at: new Date().toISOString(),
+      level,
+      text:
+        textOverride ||
+        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,
+    });
+  };
+  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",
+    "trace",
+    "dir",
+    "dirxml",
+    "table",
+  ]) {
+    const original = console[level];
+    if (typeof original !== "function") {
+      continue;
+    }
+    console[level] = function patchedConsole(...args) {
+      try {
+        const textOverride =
+          level === "trace"
+            ? truncateText(new Error(args[0] ? String(args[0]) : "console.trace").stack || "")
+            : undefined;
+        emitConsole(level, args, textOverride);
+      } catch {
+        // ignore
+      }
+      return original.apply(this, args);
+    };
+  }
+
+  if (typeof console.assert === "function") {
+    const originalAssert = console.assert;
+    console.assert = function patchedAssert(condition, ...args) {
+      try {
+        if (!condition) {
+          emitConsole("assert", args, truncateText(args[0] ? String(args[0]) : "Assertion failed"));
+        }
+      } catch {
+        // ignore
+      }
+      return originalAssert.call(this, condition, ...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);
+  };
+})();