@on-panda/on-panda-core 0.5.10

package/dist/AudioPlugin-B_mT-q95.js

@@ -0,0 +1,162 @@
+import { ref as u, computed as g, watch as w, onMounted as y, onUnmounted as C, createElementBlock as d, openBlock as p, createElementVNode as f, createCommentVNode as x } from "vue";
+import _ from "wavesurfer.js";
+import { _ as E, m as k } from "./index.core-8d8dnaVi.js";
+class W {
+  constructor() {
+    this.listeners = {};
+  }
+  on(e, s, t) {
+    if (this.listeners[e] || (this.listeners[e] = /* @__PURE__ */ new Set()), this.listeners[e].add(s), t == null ? void 0 : t.once) {
+      const n = () => {
+        this.un(e, n), this.un(e, s);
+      };
+      return this.on(e, n), n;
+    }
+    return () => this.un(e, s);
+  }
+  un(e, s) {
+    var t;
+    (t = this.listeners[e]) === null || t === void 0 || t.delete(s);
+  }
+  once(e, s) {
+    return this.on(e, s, { once: !0 });
+  }
+  unAll() {
+    this.listeners = {};
+  }
+  emit(e, ...s) {
+    this.listeners[e] && this.listeners[e].forEach((t) => t(...s));
+  }
+}
+class L extends W {
+  constructor(e) {
+    super(), this.subscriptions = [], this.options = e;
+  }
+  onInit() {
+  }
+  _init(e) {
+    this.wavesurfer = e, this.onInit();
+  }
+  destroy() {
+    this.emit("destroy"), this.subscriptions.forEach((e) => e());
+  }
+}
+function m(r, e) {
+  const s = e.xmlns ? document.createElementNS(e.xmlns, r) : document.createElement(r);
+  for (const [t, n] of Object.entries(e)) if (t === "children") for (const [o, i] of Object.entries(e)) typeof i == "string" ? s.appendChild(document.createTextNode(i)) : s.appendChild(m(o, i));
+  else t === "style" ? Object.assign(s.style, n) : t === "textContent" ? s.textContent = n : s.setAttribute(t, n.toString());
+  return s;
+}
+function v(r, e, s) {
+  const t = m(r, e || {});
+  return s == null || s.appendChild(t), t;
+}
+const S = { lineWidth: 1, labelSize: 11, formatTimeCallback: (r) => `${Math.floor(r / 60)}:${`0${Math.floor(r) % 60}`.slice(-2)}` };
+class h extends L {
+  constructor(e) {
+    super(e || {}), this.unsubscribe = () => {
+    }, this.onPointerMove = (s) => {
+      if (!this.wavesurfer) return;
+      const t = this.wavesurfer.getWrapper().getBoundingClientRect(), { width: n } = t, o = s.clientX - t.left, i = Math.min(1, Math.max(0, o / n)), c = Math.min(n - this.options.lineWidth - 1, o);
+      this.wrapper.style.transform = `translateX(${c}px)`, this.wrapper.style.opacity = "1";
+      const a = this.wavesurfer.getDuration() || 0;
+      this.label.textContent = this.options.formatTimeCallback(a * i);
+      const l = this.label.offsetWidth;
+      this.label.style.transform = c + l > n ? `translateX(-${l + this.options.lineWidth}px)` : "", this.emit("hover", i);
+    }, this.onPointerLeave = () => {
+      this.wrapper.style.opacity = "0";
+    }, this.options = Object.assign({}, S, e), this.wrapper = v("div", { part: "hover" }), this.label = v("span", { part: "hover-label" }, this.wrapper);
+  }
+  static create(e) {
+    return new h(e);
+  }
+  addUnits(e) {
+    return `${e}${typeof e == "number" ? "px" : ""}`;
+  }
+  onInit() {
+    if (!this.wavesurfer) throw Error("WaveSurfer is not initialized");
+    const e = this.wavesurfer.options, s = this.options.lineColor || e.cursorColor || e.progressColor;
+    Object.assign(this.wrapper.style, { position: "absolute", zIndex: 10, left: 0, top: 0, height: "100%", pointerEvents: "none", borderLeft: `${this.addUnits(this.options.lineWidth)} solid ${s}`, opacity: "0", transition: "opacity .1s ease-in" }), Object.assign(this.label.style, { display: "block", backgroundColor: this.options.labelBackground, color: this.options.labelColor, fontSize: `${this.addUnits(this.options.labelSize)}`, transition: "transform .1s ease-in", padding: "2px 3px" });
+    const t = this.wavesurfer.getWrapper();
+    t.appendChild(this.wrapper), t.addEventListener("pointermove", this.onPointerMove), t.addEventListener("pointerleave", this.onPointerLeave), t.addEventListener("wheel", this.onPointerMove), this.unsubscribe = () => {
+      t.removeEventListener("pointermove", this.onPointerMove), t.removeEventListener("pointerleave", this.onPointerLeave), t.removeEventListener("wheel", this.onPointerLeave);
+    };
+  }
+  destroy() {
+    super.destroy(), this.unsubscribe(), this.wrapper.remove();
+  }
+}
+const z = { class: "on-panda-audio-plugin" }, M = ["src"], P = {
+  key: 0,
+  class: "fallback-message"
+}, $ = {
+  __name: "AudioPlugin",
+  props: {
+    content: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(r) {
+    const e = r, s = u(null), t = u(null), n = u(!1);
+    let o = null;
+    const i = g(() => k(e.content).base64_url), c = () => {
+      if (!(!s.value || !t.value || !i.value))
+        try {
+          o = _.create({
+            container: s.value,
+            waveColor: "rgba(255, 165, 0, 1)",
+            // Orange
+            progressColor: "rgba(192, 192, 192, 1)",
+            // Light gray
+            media: t.value,
+            // This binds to the visible audio element
+            normalize: !0,
+            height: 60,
+            plugins: [
+              h.create({
+                lineColor: "#ff0000",
+                lineWidth: 2,
+                labelBackground: "#555",
+                labelColor: "#fff",
+                labelSize: "11px"
+              })
+            ]
+          }), o.on("ready", () => {
+            n.value = !0, s.value.addEventListener("click", (a) => {
+              const l = s.value.getBoundingClientRect(), b = (a.clientX - l.left) / l.width;
+              o.seekTo(b), t.value.play();
+            });
+          }), o.on("error", (a) => {
+            console.error("WaveSurfer error:", a), n.value = !1;
+          });
+        } catch (a) {
+          console.error("Failed to initialize WaveSurfer:", a), n.value = !1;
+        }
+    };
+    return w(i, () => {
+      o && (o.destroy(), o = null, n.value = !1), i.value && setTimeout(c, 100);
+    }, { immediate: !1 }), y(() => {
+      i.value && c();
+    }), C(() => {
+      o && o.destroy();
+    }), (a, l) => (p(), d("div", z, [
+      f("div", {
+        ref_key: "waveformContainer",
+        ref: s,
+        class: "waveform-container"
+      }, null, 512),
+      f("audio", {
+        ref_key: "audioElement",
+        ref: t,
+        src: i.value,
+        controls: "",
+        class: "audio-controls"
+      }, null, 8, M),
+      !n.value && i.value ? (p(), d("div", P, " Waveform visualization unavailable - using audio controls only ")) : x("", !0)
+    ]));
+  }
+}, I = /* @__PURE__ */ E($, [["__scopeId", "data-v-0e4cb895"]]);
+export {
+  I as default
+};

package/dist/ImagePlugin-BueR6PXa.js

@@ -0,0 +1,30 @@
+import { computed as a, createElementBlock as r, openBlock as s } from "vue";
+import { _ as i } from "./index.core-8d8dnaVi.js";
+const u = ["src"], _ = {
+  __name: "ImagePlugin",
+  props: {
+    content: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(o) {
+    const e = o, t = a(() => e.content.blob_url || e.content.image_url.url);
+    function c(n) {
+      n.target.classList.toggle("rawSizeImg");
+    }
+    function l() {
+      window.open(t.value, "_blank");
+    }
+    return (n, p) => (s(), r("img", {
+      class: "on-panda-image-plugin",
+      src: t.value,
+      alt: "<|ON_PANDA_IMAGE|>",
+      onClick: c,
+      onDblclick: l
+    }, null, 40, u));
+  }
+}, d = /* @__PURE__ */ i(_, [["__scopeId", "data-v-65b62084"]]);
+export {
+  d as default
+};

package/dist/browserAgentMcp-j4Vh1Sig.js

@@ -0,0 +1,243 @@
+const M = Object.getPrototypeOf(async function() {
+}).constructor, R = 256 * 1024, g = 200, w = 6e4, j = {
+  "image/png": "image",
+  "image/jpeg": "image",
+  "image/gif": "image",
+  "image/webp": "image",
+  "audio/wav": "audio",
+  "audio/mp3": "audio",
+  "audio/mpeg": "audio",
+  "video/mp4": "video",
+  "video/webm": "video",
+  "video/quicktime": "video"
+}, x = {
+  name: "run_browser_js",
+  description: "Run JavaScript in the current browser runtime and return logs from `console.log`. `console.log` accepts `Blob` arguments of MCP-supported image, audio, and video types, returned as inline media in your context. Each tool call uses a fresh local scope, so local variables do not persist across calls, but shared globals like window and document do persist. Your JavaScript local scope includes a `browserAgent` variable. For content that should be reused across tool calls, prefer storing it on the `browserAgent.local` object. You can access the internet under CORS restrictions. Do not refresh or switch the current webpage, as this will reset the JavaScript runtime and your context lost.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      code: {
+        type: "string",
+        description: "If your code starts any async work, such as fetch, promises, or async functions, await it with top-level await or await the returned promise; otherwise the tool may return before later logs run. Do not rely on un-awaited .then() callbacks for console.log output."
+      }
+    }
+  }
+}, $ = {
+  name: "render_svg",
+  description: "Render an SVG string into a bitmap PNG image. The tool uses the SVG width/height, or falls back to viewBox.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      svg: {
+        type: "string",
+        description: "SVG markup to render. It must start with `<svg` and end with `</svg>`."
+      }
+    }
+  }
+};
+function O(e) {
+  return new Promise((t, n) => {
+    const r = new FileReader();
+    r.onload = () => {
+      const o = r.result;
+      t(o.slice(o.indexOf(",") + 1));
+    }, r.onerror = n, r.readAsDataURL(e);
+  });
+}
+function y(e = "") {
+  return `<|js_error_start|>
+${e}
+<|js_error_end|>`;
+}
+function v(e = "", t = R) {
+  if (e.length <= t)
+    return e;
+  const n = Math.ceil(t / 2), r = t - n, o = e.length - t;
+  return `(Total length: ${e.length} characters. Showing ${t} characters after truncating the middle.)
+${e.slice(0, n)}
+<|truncate_long_text|>
+{Output exceeded ${t} characters. Omitted ${o} characters from the middle.} ......
+<|truncate_long_text|>
+${e.slice(e.length - r)}`;
+}
+async function E() {
+  return await (await (await (await (await (await navigator.storage.getDirectory()).getDirectoryHandle("browser-agent", { create: !0 })).getDirectoryHandle("memory", { create: !0 })).getFileHandle("MEMORY.md", { create: !0 })).getFile()).text();
+}
+function A(e = "") {
+  const t = e.split(`
+`), n = [];
+  let r = t.length > g ? t.slice(0, g).join(`
+`) : e;
+  return t.length > g && n.push(`original ${t.length} lines exceeded ${g} lines`), e.length > w && n.push(`original ${e.length} characters exceeded ${w} characters`), r.length > w && (r = r.slice(0, w)), {
+    text: r,
+    truncationReason: n.length ? `Truncated: ${n.join("; ")}. So, find an opportunity to organize the memory: clean up or archive outdated or unimportant information, move less important content out of the MEMORY.md into other files or folders under \`browser-agent/memory/\`, and keep only brief descriptions and references in the MEMORY.md so you can read the archived content later when needed.` : ""
+  };
+}
+async function B() {
+  const e = `## Persistent memory
+Persistent memory is stored in files or folders under \`browser-agent/memory/\` in the current origin's OPFS. Use \`run_browser_js\` and \`navigator.storage.getDirectory()\` to record, modify, and query memory when needed. \`browser-agent/memory/MEMORY.md\` is always loaded into your conversation context. Keep it concise; it is truncated after ${g} lines or ${w} characters.`, t = await E();
+  if (!t.trim())
+    return `${e}
+The current \`browser-agent/memory/MEMORY.md\` is empty.`;
+  const { text: n, truncationReason: r } = A(t);
+  return `${e}
+### the MEMORY.md
+<|browser_agent_memory_start|>
+${n}
+<|browser_agent_memory_end|>${r ? `
+${r}` : ""}`;
+}
+async function U(e = "", t) {
+  const n = [], r = [], o = performance.now(), s = {
+    ...console,
+    log(...i) {
+      const a = i.map((c) => {
+        const f = c instanceof Blob ? j[c.type] : null;
+        if (f) {
+          const b = { type: f, mimeType: c.type, data: "" };
+          return r.push(O(c).then((S) => {
+            b.data = S;
+          })), b;
+        }
+        return String(c);
+      });
+      n.push({ kind: "log", row: a }), console.log("[run_browser_js.log]:", ...i);
+    },
+    error(...i) {
+      const a = i.map((c) => String(c)).join(" ");
+      n.push({ kind: "error", text: y(a) }), console.log("[run_browser_js.error]:", a);
+    }
+  }, p = t({ callScope: { console: s } });
+  try {
+    await new M("console", "browserAgent", e)(s, p);
+  } catch (i) {
+    const a = String(i);
+    n.push({ kind: "error", text: y(a) }), console.log("[run_browser_js.error]:", a);
+  }
+  await Promise.all(r);
+  const h = [{
+    type: "text",
+    text: `<|execution_info_start|>
+Code execution time: ${Math.round(performance.now() - o)} ms
+<|execution_info_end|>`
+  }];
+  n.some((i) => i.kind === "log") || h.push({ type: "text", text: "<|no_js_log|>" });
+  let l = "";
+  const u = () => {
+    l && (h.push({ type: "text", text: v(l) }), l = "");
+  };
+  return n.forEach((i) => {
+    i.kind === "log" ? i.row.forEach((a, c) => {
+      typeof a == "string" ? (l && (l += c === 0 ? `
+` : " "), l += a) : (u(), h.push(a));
+    }) : (u(), h.push({ type: "text", text: v(i.text) }));
+  }), u(), h;
+}
+async function F(e = "") {
+  const t = URL.createObjectURL(new Blob([e], { type: "image/svg+xml" }));
+  try {
+    const n = await new Promise((h, l) => {
+      const u = new Image();
+      u.onload = () => h(u), u.onerror = l, u.src = t;
+    }), r = new DOMParser().parseFromString(e, "image/svg+xml").documentElement, o = Number.parseFloat(r.getAttribute("width")), s = Number.parseFloat(r.getAttribute("height")), p = (r.getAttribute("viewBox") || "").trim().split(/[\s,]+/).map(Number), d = document.createElement("canvas");
+    return d.width = Number.isFinite(o) && Number.isFinite(s) ? o : p.length === 4 ? p[2] : n.naturalWidth, d.height = Number.isFinite(o) && Number.isFinite(s) ? s : p.length === 4 ? p[3] : n.naturalHeight, d.getContext("2d").drawImage(n, 0, 0, d.width, d.height), d.toDataURL("image/png").slice(22);
+  } finally {
+    URL.revokeObjectURL(t);
+  }
+}
+function k(e, t = {}) {
+  return new Response(JSON.stringify(e), {
+    status: 200,
+    headers: {
+      "content-type": "application/json"
+    },
+    ...t
+  });
+}
+function m(e, t) {
+  return k({
+    jsonrpc: "2.0",
+    id: e,
+    result: t
+  });
+}
+function _(e, t, n) {
+  return k({
+    jsonrpc: "2.0",
+    id: e,
+    error: {
+      code: t,
+      message: n
+    }
+  });
+}
+async function I({ message: e = {}, instructions: t = "", buildBrowserAgent: n } = {}) {
+  var r, o;
+  if (e.method === "initialize")
+    return m(e.id, {
+      protocolVersion: e.params.protocolVersion,
+      capabilities: {
+        tools: {}
+      },
+      serverInfo: {
+        name: "browser-agent-mcp",
+        version: "0.1.0"
+      },
+      instructions: t
+    });
+  if (e.method === "ping")
+    return m(e.id, {});
+  if (e.method === "tools/list")
+    return m(e.id, {
+      tools: [x, $]
+    });
+  if (e.method === "tools/call") {
+    if (e.params.name === "run_browser_js") {
+      const s = await U(((r = e.params.arguments) == null ? void 0 : r.code) || "", n);
+      return m(e.id, { content: s });
+    }
+    if (e.params.name === "render_svg") {
+      const s = await F(((o = e.params.arguments) == null ? void 0 : o.svg) || "");
+      return m(e.id, {
+        content: [{ type: "image", mimeType: "image/png", data: s }]
+      });
+    }
+    return _(e.id, -32601, `Tool not found: ${e.params.name}`);
+  }
+  return e.id == null ? new Response(null, { status: 204 }) : _(e.id, -32601, `Method not found: ${e.method}`);
+}
+async function T({ proxyPath: e = "" } = {}) {
+  return `You are an agent running in a browser. You are operating in the JavaScript runtime of the current webpage, where the user interacts with you. Please make the appropriate adjustments for this browser JavaScript environment.
+
+## Skills
+A skill is a set of instructions to follow that is stored in a \`SKILL.md\` file. Below is the list of skills that can be used. Each entry includes a name, description, and skillUrl so you can open the source for full instructions when using a specific skill.
+### Available skills
+- \`cors-internet\`: Skill for web search and information retrieval under CORS. Use when you need to access the internet. ([skillUrl](https://raw.githubusercontent.com/on-panda/browser-agent-skills/main/skills/cors-internet/SKILL.md))${e ? `
+    - Fallback: for critical resources that even cors-internet cannot reach, use the server-side proxy at \`${e}/{url}\`.` : ""}
+- \`interactive-webpage\`: Use when you need to create webpages or interactive artifacts, or modify the current UI. ([skillUrl](https://raw.githubusercontent.com/on-panda/browser-agent-skills/main/skills/interactive-webpage/SKILL.md))
+- \`user-local-files\`: Use when the user shares local files, indicated by \`<|user_local_files\` in the context. Includes local filesystem read/write guidelines and common tools. ([skillUrl](https://raw.githubusercontent.com/on-panda/browser-agent-skills/main/skills/user-local-files/SKILL.md))
+### How to load skills
+If the task clearly matches a skill's description shown above, using tool "run_browser_js" with this pattern code to load the skill:
+\`\`\`js
+await fetch(skillUrl).then(res => res.text()).then(console.log)
+\`\`\`
+
+${await B()}`;
+}
+function L({ buildBrowserAgent: e, proxyPath: t = "" } = {}) {
+  return {
+    localFetch: async function(r, o = {}) {
+      if ((o.method || "GET") !== "POST")
+        return new Response(null, { status: 405 });
+      const s = JSON.parse(o.body || "{}");
+      return await I({
+        message: s,
+        instructions: s.method === "initialize" ? await T({ proxyPath: t }) : "",
+        buildBrowserAgent: e
+      });
+    }
+  };
+}
+export {
+  L as BrowserAgentMcpClosure
+};

package/dist/defaultCustom-l0sNRNKZ.js

@@ -0,0 +1 @@
+