codetraxis 1.0.1 → 1.0.2

package/codetraxisAgent/interceptors/consoleInterceptor.ts

@@ -0,0 +1,33 @@
+/**
+ * codetraxis agent — console interceptor.
+ */
+import type { TreeViewerBridge } from "../shared";
+
+const INSTALLED_KEY = "__tv_console_installed__";
+
+export function setupConsoleInterceptor(bridge: TreeViewerBridge): void {
+  const g = globalThis as Record<string, any>;
+  if (g[INSTALLED_KEY]) return;
+  g[INSTALLED_KEY] = true;
+
+  const original = {
+    log:   console.log.bind(console),
+    info:  console.info.bind(console),
+    warn:  console.warn.bind(console),
+    error: console.error.bind(console),
+  };
+
+  (["log", "info", "warn", "error"] as const).forEach(level => {
+    // @ts-ignore
+    console[level] = (...args: unknown[]) => {
+      original[level](...args);
+      bridge.send({
+        id: bridge.uid(),
+        type: "console",
+        level,
+        args: args.map(a => bridge.safeSerialize(a)),
+        timestamp: Date.now(),
+      });
+    };
+  });
+}

package/codetraxisAgent/interceptors/fetchInterceptor.ts

@@ -0,0 +1,93 @@
+/**
+ * codetraxis agent — fetch interceptor.
+ */
+import type { TreeViewerBridge } from "../shared";
+
+const INSTALLED_KEY = "__tv_fetch_installed__";
+
+function normalizeHeaders(headers: HeadersInit | undefined): Record<string, string> | undefined {
+  if (!headers) return undefined;
+  const result: Record<string, string> = {};
+  try {
+    if (headers instanceof Headers) {
+      headers.forEach((v, k) => { result[k] = v; });
+    } else if (Array.isArray(headers)) {
+      (headers as [string, string][]).forEach(([k, v]) => { result[k] = v; });
+    } else {
+      Object.assign(result, headers as Record<string, string>);
+    }
+    return result;
+  } catch { return undefined; }
+}
+
+export function setupFetchInterceptor(bridge: TreeViewerBridge): void {
+  const g = globalThis as Record<string, any>;
+  if (g[INSTALLED_KEY]) return;
+  g[INSTALLED_KEY] = true;
+
+  const originalFetch =
+    typeof globalThis.fetch === "function"
+      ? globalThis.fetch.bind(globalThis)
+      : null;
+  if (!originalFetch) return;
+
+  globalThis.fetch = async function tvFetch(
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ): Promise<Response> {
+    const url =
+      typeof input === "string" ? input
+      : input instanceof URL   ? input.href
+      : (input as Request).url;
+
+    const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+    const id    = bridge.uid();
+    const start = Date.now();
+
+    const requestHeaders = normalizeHeaders(
+      init?.headers ?? (input instanceof Request ? input.headers : undefined),
+    );
+
+    let requestBody: string | undefined;
+    const rawBody = init?.body;
+    if (rawBody != null) {
+      try {
+        requestBody =
+          typeof rawBody === "string"       ? bridge.truncate(rawBody)
+          : rawBody instanceof URLSearchParams ? bridge.truncate(rawBody.toString())
+          : "[binary]";
+      } catch { requestBody = "[unserializable-body]"; }
+    }
+
+    bridge.send({ id, type: "network", transport: "fetch", method, url,
+      requestHeaders, requestBody, state: "pending", timestamp: start });
+
+    try {
+      const response = await originalFetch(input, init);
+
+      let responseHeaders: Record<string, string> | undefined;
+      try {
+        responseHeaders = {};
+        response.headers.forEach((v, k) => { responseHeaders![k] = v; });
+      } catch { /* ignore */ }
+
+      let responseBody: string | undefined;
+      try { responseBody = bridge.truncate(await response.clone().text()); }
+      catch { responseBody = "[binary]"; }
+
+      bridge.send({ id, type: "network", transport: "fetch", method, url,
+        status: response.status, requestHeaders, requestBody,
+        responseHeaders, responseBody,
+        state: response.ok ? "success" : "error",
+        duration: Date.now() - start, timestamp: start });
+
+      return response;
+    } catch (error) {
+      bridge.send({ id, type: "network", transport: "fetch", method, url,
+        requestHeaders, requestBody, state: "error",
+        duration: Date.now() - start, timestamp: start,
+        error: bridge.safeSerialize(error) });
+      throw error;
+    }
+  };
+}

package/codetraxisAgent/interceptors/xhrInterceptor.ts

@@ -0,0 +1,88 @@
+/**
+ * codetraxis agent — XHR interceptor.
+ * Patches XMLHttpRequest.prototype so existing references (e.g. axios
+ * internals captured at import time) are also intercepted.
+ * Works in browser and React Native (which ships its own XHR polyfill).
+ */
+import type { TreeViewerBridge } from "../shared";
+
+const INSTALLED_KEY = "__tv_xhr_installed__";
+
+export function setupXhrInterceptor(bridge: TreeViewerBridge): void {
+  if (typeof XMLHttpRequest === "undefined") return;
+  const g = globalThis as Record<string, any>;
+  if (g[INSTALLED_KEY]) return;
+  g[INSTALLED_KEY] = true;
+
+  try {
+    const proto = XMLHttpRequest.prototype;
+
+    const _origOpen = proto.open;
+    proto.open = function(this: XMLHttpRequest, method: string, url: string, ...rest: unknown[]) {
+      (this as any).__tv_method     = method.toUpperCase();
+      (this as any).__tv_url        = String(url);
+      (this as any).__tv_reqHeaders = undefined;
+      return (_origOpen as Function).apply(this, [method, url, ...rest]);
+    };
+
+    const _origSetHeader = proto.setRequestHeader;
+    proto.setRequestHeader = function(this: XMLHttpRequest, name: string, value: string) {
+      if (!(this as any).__tv_reqHeaders) (this as any).__tv_reqHeaders = {} as Record<string, string>;
+      (this as any).__tv_reqHeaders[name] = value;
+      return _origSetHeader.apply(this, [name, value]);
+    };
+
+    const _origSend = proto.send;
+    proto.send = function(this: XMLHttpRequest, body?: Document | XMLHttpRequestBodyInit | null) {
+      const id         = bridge.uid();
+      const method     = (this as any).__tv_method ?? "GET";
+      const url        = (this as any).__tv_url    ?? "";
+      const reqHeaders = (this as any).__tv_reqHeaders as Record<string, string> | undefined;
+      const start      = Date.now();
+
+      let requestBody: string | undefined;
+      if (body != null) {
+        try {
+          requestBody =
+            typeof body === "string"       ? bridge.truncate(body)
+            : body instanceof URLSearchParams ? bridge.truncate(body.toString())
+            : "[binary]";
+        } catch { /* ignore */ }
+      }
+
+      bridge.send({ id, type: "network", transport: "xhr", method, url,
+        requestBody, requestHeaders: reqHeaders, state: "pending", timestamp: start });
+
+      this.addEventListener("load", () => {
+        let responseBody: string | undefined;
+        try { responseBody = bridge.truncate(this.responseText); } catch { /* binary */ }
+
+        let responseHeaders: Record<string, string> | undefined;
+        try {
+          const raw = this.getAllResponseHeaders();
+          if (raw) {
+            responseHeaders = {};
+            raw.trim().split(/\r?\n/).forEach(line => {
+              const idx = line.indexOf(": ");
+              if (idx > 0) responseHeaders![line.slice(0, idx).toLowerCase()] = line.slice(idx + 2);
+            });
+          }
+        } catch { /* ignore */ }
+
+        bridge.send({ id, type: "network", transport: "xhr", method, url,
+          status: this.status, requestBody, requestHeaders: reqHeaders,
+          responseBody, responseHeaders,
+          state: this.status >= 200 && this.status < 400 ? "success" : "error",
+          duration: Date.now() - start, timestamp: start });
+      });
+
+      this.addEventListener("error", () => {
+        bridge.send({ id, type: "network", transport: "xhr", method, url,
+          requestBody, requestHeaders: reqHeaders,
+          state: "error", duration: Date.now() - start, timestamp: start });
+      });
+
+      return _origSend.apply(this, [body]);
+    };
+  } catch { /* not available */ }
+}

package/codetraxisAgent/shared.ts

@@ -0,0 +1,97 @@
+/**
+ * codetraxis agent — shared bridge.
+ * __PORT__ is replaced at install time with the actual server port.
+ */
+
+export type TreeViewerEvent = Record<string, unknown>;
+
+export interface TreeViewerBridge {
+  send: (event: TreeViewerEvent) => void;
+  uid: () => string;
+  safeSerialize: (value: unknown, depth?: number) => unknown;
+  truncate: (value: string, max?: number) => string;
+  isWeb: boolean;
+}
+
+export function createTreeViewerBridge(serverPort: string): TreeViewerBridge {
+  const g = globalThis as Record<string, any>;
+
+  const isWeb: boolean =
+    typeof g.document !== "undefined" &&
+    typeof g.addEventListener === "function";
+
+  let ws: WebSocket | null = null;
+  let wsReady = false;
+  const queue: string[] = [];
+
+  const getHost = (): string => {
+    if (typeof g.__TREE_VIEWER_HOST__ === "string" && g.__TREE_VIEWER_HOST__) {
+      return g.__TREE_VIEWER_HOST__ as string;
+    }
+    if (isWeb && g.location?.hostname) return g.location.hostname as string;
+    return "localhost";
+  };
+
+  const connect = () => {
+    try {
+      const WS =
+        typeof WebSocket !== "undefined"
+          ? WebSocket
+          : (g.WebSocket as typeof WebSocket | undefined);
+      if (!WS) return;
+
+      ws = new WS(`ws://${getHost()}:${serverPort}/agent`);
+      ws.onopen  = () => {
+        wsReady = true;
+        while (queue.length > 0) {
+          const item = queue.shift();
+          if (item && ws) ws.send(item);
+        }
+      };
+      ws.onclose = () => { wsReady = false; setTimeout(connect, 3000); };
+      ws.onerror = () => { wsReady = false; };
+    } catch { /* unavailable */ }
+  };
+  connect();
+
+  const truncate = (value: string, max = 500000): string =>
+    value.length > max ? `${value.slice(0, max)}…[truncated]` : value;
+
+  const safeSerialize = (value: unknown, depth = 0): unknown => {
+    if (depth > 4)            return "[depth limit]";
+    if (value == null)        return value;
+    if (typeof value === "function") return `[Function: ${(value as Function).name || "anonymous"}]`;
+    if (typeof value === "symbol")   return value.toString();
+    if (typeof value !== "object")   return value;
+    if (value instanceof Error) return { __error: true, name: value.name, message: value.message, stack: value.stack };
+    if (Array.isArray(value))   return value.slice(0, 1000).map(i => safeSerialize(i, depth + 1));
+
+    const seen = new WeakSet<object>();
+    const walk = (obj: object, d: number): Record<string, unknown> | string => {
+      if (seen.has(obj)) return "[circular]";
+      seen.add(obj);
+      const r: Record<string, unknown> = {};
+      let n = 0;
+      for (const k in obj as Record<string, unknown>) {
+        if (n++ > 500) { r["..."] = "[truncated]"; break; }
+        try { r[k] = safeSerialize((obj as Record<string, unknown>)[k], d + 1); }
+        catch { r[k] = "[unserializable]"; }
+      }
+      return r;
+    };
+    return walk(value as object, depth);
+  };
+
+  const uid = () =>
+    `${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+
+  const send = (event: TreeViewerEvent) => {
+    try {
+      const payload = JSON.stringify(event);
+      if (wsReady && ws) { ws.send(payload); }
+      else { queue.push(payload); if (queue.length > 200) queue.shift(); }
+    } catch { /* ignore */ }
+  };
+
+  return { send, uid, safeSerialize, truncate, isWeb };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "codetraxis",
-    "version": "1.0.1",
+    "version": "1.0.2",
     "description": "React & React Native debug tool with network inspector, console timeline and live file explorer",
     "keywords": [
         "react debug tool",
@@ -30,7 +30,8 @@
     "files": [
         "bin",
         "server/dist",
-        "client/dist"
+        "client/dist",
+        "codetraxisAgent"
     ],
     "scripts": {
         "dev": "concurrently \"npm run dev --prefix client\" \"npm run dev --prefix server\"",