@surething/cockpit 1.0.175

package/chrome-extension/network-capture.js

@@ -0,0 +1,197 @@
+/**
+ * Network Capture - Main World 网络拦截
+ *
+ * 注入到 iframe 的 main world（和 disguise.js 同方式），
+ * 拦截真实的 fetch / XMLHttpRequest，通过 CustomEvent 把
+ * 捕获的请求条目发送回 Isolated World 的 automation.js。
+ *
+ * 通信协议：
+ *   Main → Isolated:  cockpit:network-entry   { ...entry }       请求发起时立即发送（占位）
+ *   Main → Isolated:  cockpit:network-update  { id, status, ... } 响应完成时发送（补全字段）
+ *   Isolated → Main:  cockpit:network-recording { active, filters }
+ *   Isolated → Main:  cockpit:network-bridge-ready  (触发 buffer flush)
+ */
+(function () {
+  'use strict';
+
+  let networkReqId = 0;
+  const MAX_BODY_SIZE = 128 * 1024;
+
+  // 录制状态（由 Isolated World 的 automation.js 同步过来）
+  let recording = { active: false, filters: {} };
+
+  // Bridge 就绪前缓存条目，防止 automation.js 还没 import 完时丢条目
+  let entryBuffer = [];
+  let bridgeReady = false;
+
+  // ── 事件监听 ────────────────────────────────────────────
+
+  window.addEventListener('cockpit:network-recording', function (e) {
+    recording = e.detail;
+  });
+
+  window.addEventListener('cockpit:network-bridge-ready', function () {
+    bridgeReady = true;
+    if (entryBuffer.length) {
+      entryBuffer.forEach(emitEntry);
+      entryBuffer = [];
+    }
+  });
+
+  // ── 工具函数 ────────────────────────────────────────────
+
+  function shouldCaptureBody(method, url, status) {
+    if (!recording.active) return false;
+    var f = recording.filters;
+    if (f.method && method.toUpperCase() !== f.method.toUpperCase()) return false;
+    if (f.url) {
+      var pattern = f.url.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+      if (!new RegExp(pattern, 'i').test(url)) return false;
+    }
+    if (f.status && status != null) {
+      var ranges = f.status.split(',').map(function (s) { return s.trim(); });
+      var match = ranges.some(function (range) {
+        if (range.endsWith('xx')) { var base = parseInt(range[0]) * 100; return status >= base && status < base + 100; }
+        return status === parseInt(range);
+      });
+      if (!match) return false;
+    }
+    return true;
+  }
+
+  function captureBody(text) {
+    if (text == null) return null;
+    if (text.length > MAX_BODY_SIZE) return { truncated: true, size: text.length };
+    return text;
+  }
+
+  function emitEntry(entry) {
+    if (!bridgeReady) { entryBuffer.push(entry); return; }
+    window.dispatchEvent(new CustomEvent('cockpit:network-entry', { detail: entry }));
+  }
+
+  function emitUpdate(update) {
+    window.dispatchEvent(new CustomEvent('cockpit:network-update', { detail: update }));
+  }
+
+  // ── Fetch 拦截 ──────────────────────────────────────────
+
+  var originalFetch = window.fetch;
+  window.fetch = async function () {
+    var args = arguments;
+    var id = ++networkReqId;
+    var req = args[0] instanceof Request ? args[0] : new Request(args[0], args[1]);
+    var wantBody = shouldCaptureBody(req.method, req.url, null);
+
+    var reqHeaders = null;
+    var reqBody = null;
+    if (wantBody) {
+      reqHeaders = {};
+      req.headers.forEach(function (v, k) { reqHeaders[k] = v; });
+      try { reqBody = captureBody(await req.clone().text()); } catch (e) { /* ignore */ }
+    }
+
+    var entry = {
+      id: id, method: req.method, url: req.url, type: 'fetch',
+      startTime: Date.now(), status: null, duration: null,
+      requestHeaders: reqHeaders, requestBody: reqBody,
+      responseHeaders: null, responseBody: null, responseSize: null,
+      recorded: wantBody,
+    };
+    // 立即 emit 占位条目，保持请求发起顺序
+    emitEntry(entry);
+
+    try {
+      var res = await originalFetch.apply(this, args);
+      var update = { id: id, status: res.status, duration: Date.now() - entry.startTime };
+      var capture = wantBody || shouldCaptureBody(req.method, req.url, res.status);
+      if (capture) {
+        update.recorded = true;
+        var resHeaders = {};
+        res.headers.forEach(function (v, k) { resHeaders[k] = v; });
+        update.responseHeaders = resHeaders;
+        if (!reqHeaders) {
+          update.requestHeaders = {};
+          req.headers.forEach(function (v, k) { update.requestHeaders[k] = v; });
+        }
+        var ct = res.headers.get('content-type') || '';
+        if (ct.includes('json') || ct.includes('text') || ct.includes('xml') || ct.includes('html') || ct.includes('javascript')) {
+          try {
+            var text = await res.clone().text();
+            update.responseSize = text.length;
+            update.responseBody = captureBody(text);
+          } catch (e) { /* ignore */ }
+        }
+      }
+      emitUpdate(update);
+      return res;
+    } catch (err) {
+      emitUpdate({ id: id, status: 0, duration: Date.now() - entry.startTime, error: err.message });
+      throw err;
+    }
+  };
+
+  // ── XMLHttpRequest 拦截 ─────────────────────────────────
+
+  var XHROpen = XMLHttpRequest.prototype.open;
+  var XHRSend = XMLHttpRequest.prototype.send;
+  var XHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+
+  XMLHttpRequest.prototype.open = function (method, url) {
+    this._cockpit = { method: method, url: String(url), id: ++networkReqId };
+    return XHROpen.apply(this, arguments);
+  };
+
+  XMLHttpRequest.prototype.setRequestHeader = function (name, value) {
+    if (this._cockpit) {
+      if (!this._cockpit.requestHeaders) this._cockpit.requestHeaders = {};
+      this._cockpit.requestHeaders[name.toLowerCase()] = value;
+    }
+    return XHRSetRequestHeader.apply(this, arguments);
+  };
+
+  XMLHttpRequest.prototype.send = function (body) {
+    if (this._cockpit) {
+      var wantBody = shouldCaptureBody(this._cockpit.method, this._cockpit.url, null);
+      var entryId = this._cockpit.id;
+      var entry = {
+        id: entryId, method: this._cockpit.method,
+        url: this._cockpit.url, type: 'xhr',
+        startTime: Date.now(), status: null, duration: null,
+        requestHeaders: wantBody ? (this._cockpit.requestHeaders || null) : null,
+        requestBody: wantBody && typeof body === 'string' ? captureBody(body) : null,
+        responseHeaders: null, responseBody: null, responseSize: null,
+        recorded: wantBody,
+      };
+      // 立即 emit 占位条目，保持请求发起顺序
+      emitEntry(entry);
+      var entryMethod = entry.method;
+      var entryUrl = entry.url;
+      var entryStartTime = entry.startTime;
+      this.addEventListener('loadend', function () {
+        var update = { id: entryId, status: this.status, duration: Date.now() - entryStartTime };
+        var capture = wantBody || shouldCaptureBody(entryMethod, entryUrl, this.status);
+        if (capture) {
+          update.recorded = true;
+          try {
+            var raw = this.getAllResponseHeaders();
+            var headers = {};
+            raw.trim().split(/[\r\n]+/).forEach(function (line) {
+              var parts = line.split(': ');
+              var k = parts.shift();
+              if (k) headers[k.toLowerCase()] = parts.join(': ');
+            });
+            update.responseHeaders = headers;
+          } catch (e) { /* ignore */ }
+          try {
+            var text = this.responseText;
+            update.responseSize = text.length;
+            update.responseBody = captureBody(text);
+          } catch (e) { /* ignore */ }
+        }
+        emitUpdate(update);
+      });
+    }
+    return XHRSend.apply(this, arguments);
+  };
+})();

package/chrome-extension/rules.json

@@ -0,0 +1,56 @@
+[
+  {
+    "id": 1,
+    "priority": 1,
+    "action": {
+      "type": "modifyHeaders",
+      "responseHeaders": [
+        { "header": "X-Frame-Options", "operation": "remove" },
+        { "header": "Content-Security-Policy", "operation": "remove" },
+        { "header": "Content-Security-Policy-Report-Only", "operation": "remove" },
+        { "header": "Cross-Origin-Opener-Policy", "operation": "remove" },
+        { "header": "Cross-Origin-Embedder-Policy", "operation": "remove" },
+        { "header": "Cross-Origin-Resource-Policy", "operation": "remove" }
+      ]
+    },
+    "condition": {
+      "resourceTypes": ["sub_frame"]
+    }
+  },
+  {
+    "id": 2,
+    "priority": 1,
+    "action": {
+      "type": "modifyHeaders",
+      "requestHeaders": [
+        { "header": "Sec-Fetch-Dest", "operation": "set", "value": "document" },
+        { "header": "Sec-Fetch-Mode", "operation": "set", "value": "navigate" },
+        { "header": "Sec-Fetch-Site", "operation": "set", "value": "none" },
+        { "header": "Sec-Fetch-User", "operation": "set", "value": "?1" }
+      ]
+    },
+    "condition": {
+      "resourceTypes": ["sub_frame"],
+      "initiatorDomains": ["localhost", "127.0.0.1"]
+    }
+  },
+  {
+    "id": 3,
+    "priority": 2,
+    "action": {
+      "type": "redirect",
+      "redirect": {
+        "transform": {
+          "queryTransform": {
+            "removeParams": ["_cockpit"]
+          }
+        }
+      }
+    },
+    "condition": {
+      "resourceTypes": ["sub_frame"],
+      "urlFilter": "_cockpit=",
+      "initiatorDomains": ["localhost", "127.0.0.1"]
+    }
+  }
+]

package/dist/JupyterKernelManager-475VNVA5.mjs

@@ -0,0 +1,248 @@
+// src/lib/kernels/JupyterKernelManager.ts
+import { spawn } from "child_process";
+import { join } from "path";
+import { createInterface } from "readline";
+var GLOBAL_KEY = /* @__PURE__ */ Symbol.for("jupyter_kernel_manager");
+var IDLE_TIMEOUT = 10 * 60 * 1e3;
+var IDLE_CHECK_INTERVAL = 60 * 1e3;
+var JupyterKernelManager = class {
+  constructor() {
+    this.instances = /* @__PURE__ */ new Map();
+    this.idleTimer = null;
+    process.on("exit", () => {
+      this.shutdownAll();
+    });
+  }
+  /**
+   * Find python3 executable
+   */
+  findPython() {
+    return "python3";
+  }
+  /**
+   * Get or create a kernel for a bubble
+   */
+  async getOrCreate(bubbleId, cwd) {
+    const existing = this.instances.get(bubbleId);
+    if (existing) {
+      existing.lastUsedAt = Date.now();
+      await existing.readyPromise;
+      return existing;
+    }
+    const python = this.findPython();
+    const bridgePath = join(__dirname, "jupyter_bridge.py");
+    const bridge = spawn(python, ["-u", bridgePath], {
+      cwd,
+      env: {
+        ...process.env,
+        JUPYTER_CWD: cwd,
+        PYTHONUNBUFFERED: "1"
+      },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const readline = createInterface({ input: bridge.stdout });
+    let resolveReady;
+    let rejectReady;
+    const readyPromise = new Promise((resolve, reject) => {
+      resolveReady = resolve;
+      rejectReady = reject;
+    });
+    const instance = {
+      bubbleId,
+      cwd,
+      bridge,
+      readline,
+      ready: false,
+      readyPromise,
+      lastUsedAt: Date.now(),
+      outputListeners: /* @__PURE__ */ new Set()
+    };
+    this.instances.set(bubbleId, instance);
+    readline.on("line", (line) => {
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        return;
+      }
+      const type = msg.type;
+      if (type === "ready") {
+        instance.ready = true;
+        resolveReady();
+      } else if (type === "error") {
+        const errorMsg = msg.message;
+        instance.errorMessage = errorMsg;
+        console.error(`[jupyter-kernel] ${bubbleId}: ${errorMsg}`);
+        if (!instance.ready) {
+          rejectReady(new Error(errorMsg));
+        }
+        const output = {
+          msg_id: "",
+          msg_type: "kernel_error",
+          content: { message: errorMsg }
+        };
+        for (const listener of instance.outputListeners) {
+          listener(output);
+        }
+      } else if (msg.msg_id !== void 0) {
+        const output = {
+          msg_id: msg.msg_id,
+          msg_type: msg.msg_type,
+          content: msg.content
+        };
+        for (const listener of instance.outputListeners) {
+          listener(output);
+        }
+      }
+    });
+    bridge.stderr?.on("data", (data) => {
+      const text = data.toString().trim();
+      if (text) {
+        console.error(`[jupyter-kernel] ${bubbleId} stderr: ${text}`);
+      }
+    });
+    bridge.on("exit", (code) => {
+      console.log(`[jupyter-kernel] ${bubbleId} bridge exited with code ${code}`);
+      readline.close();
+      this.instances.delete(bubbleId);
+      if (!instance.ready) {
+        rejectReady(new Error(`Bridge exited with code ${code}`));
+      }
+      const output = {
+        msg_id: "",
+        msg_type: "kernel_died",
+        content: { exit_code: code }
+      };
+      for (const listener of instance.outputListeners) {
+        listener(output);
+      }
+    });
+    bridge.on("error", (err) => {
+      console.error(`[jupyter-kernel] ${bubbleId} spawn error:`, err.message);
+      instance.errorMessage = err.message.includes("ENOENT") ? "Python not found. Ensure python3 is installed and in PATH." : err.message;
+      if (!instance.ready) {
+        rejectReady(new Error(instance.errorMessage));
+      }
+    });
+    this.startIdleTimer();
+    try {
+      await readyPromise;
+    } catch {
+    }
+    return instance;
+  }
+  /**
+   * Execute code in a kernel
+   */
+  async execute(bubbleId, code, msgId, cwd) {
+    let instance = this.instances.get(bubbleId);
+    if (!instance) {
+      if (!cwd) throw new Error("Kernel not found and no cwd provided");
+      instance = await this.getOrCreate(bubbleId, cwd);
+    }
+    if (!instance.ready) {
+      throw new Error(instance.errorMessage || "Kernel not ready");
+    }
+    instance.lastUsedAt = Date.now();
+    const cmd = JSON.stringify({ cmd: "execute", msg_id: msgId, code });
+    instance.bridge.stdin.write(cmd + "\n");
+  }
+  /**
+   * Interrupt the kernel
+   */
+  async interrupt(bubbleId) {
+    const instance = this.instances.get(bubbleId);
+    if (!instance || !instance.ready) return;
+    const cmd = JSON.stringify({ cmd: "interrupt" });
+    instance.bridge.stdin.write(cmd + "\n");
+  }
+  /**
+   * Shutdown a kernel
+   */
+  async shutdown(bubbleId) {
+    const instance = this.instances.get(bubbleId);
+    if (!instance) return;
+    try {
+      if (instance.bridge.stdin?.writable) {
+        instance.bridge.stdin.write(JSON.stringify({ cmd: "shutdown" }) + "\n");
+      }
+    } catch {
+    }
+    setTimeout(() => {
+      try {
+        instance.bridge.kill("SIGKILL");
+      } catch {
+      }
+    }, 3e3);
+    instance.readline.close();
+    this.instances.delete(bubbleId);
+    if (this.instances.size === 0) {
+      this.stopIdleTimer();
+    }
+  }
+  /**
+   * Shutdown all kernels
+   */
+  shutdownAll() {
+    for (const [id] of this.instances) {
+      this.shutdown(id);
+    }
+    this.stopIdleTimer();
+  }
+  /**
+   * Subscribe to kernel output messages
+   */
+  addOutputListener(bubbleId, listener) {
+    const instance = this.instances.get(bubbleId);
+    if (!instance) return () => {
+    };
+    instance.outputListeners.add(listener);
+    return () => {
+      instance.outputListeners.delete(listener);
+    };
+  }
+  /**
+   * Check if a kernel exists for a bubble
+   */
+  has(bubbleId) {
+    return this.instances.has(bubbleId);
+  }
+  /**
+   * Get kernel error message if any
+   */
+  getError(bubbleId) {
+    return this.instances.get(bubbleId)?.errorMessage;
+  }
+  // ============================================
+  // Idle timeout
+  // ============================================
+  startIdleTimer() {
+    if (this.idleTimer) return;
+    this.idleTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [id, instance] of this.instances) {
+        if (now - instance.lastUsedAt > IDLE_TIMEOUT) {
+          console.log(`[jupyter-kernel] idle timeout: ${id}`);
+          this.shutdown(id);
+        }
+      }
+      if (this.instances.size === 0) {
+        this.stopIdleTimer();
+      }
+    }, IDLE_CHECK_INTERVAL);
+    if (typeof this.idleTimer.unref === "function") {
+      this.idleTimer.unref();
+    }
+  }
+  stopIdleTimer() {
+    if (this.idleTimer) {
+      clearInterval(this.idleTimer);
+      this.idleTimer = null;
+    }
+  }
+};
+var g = globalThis;
+var kernelManager = g[GLOBAL_KEY] ?? (g[GLOBAL_KEY] = new JupyterKernelManager());
+export {
+  kernelManager
+};