jishushell 0.4.24 → 0.5.15

package/dist/services/runtime/mcp-shims/anythingllm-shim.js

@@ -0,0 +1,281 @@
+/**
+ * AnythingLLM MCP shim — exposes the user's installed AnythingLLM
+ * workspace as a single `kb_search(query)` MCP tool to the agent
+ * inside the OpenClaw container.
+ *
+ * Why a shim, not direct MCP:
+ *   AnythingLLM speaks HTTP REST (`/api/v1/workspace/{slug}/chat`),
+ *   not MCP. The shim translates one MCP tool call into one
+ *   workspace-chat HTTP call and packages the textResponse + sources
+ *   array as a text content block for the agent.
+ *
+ * Wiring: the OpenClaw adapter writes this shim into
+ * `__mcp_shims__/anythingllm/anythingllm-shim.js` per instance and
+ * registers it in mcporter.json under the `kb` server name.
+ * Non-secret config (baseUrl + workspace) is baked into the source by
+ * `substituteAnythingllmShimPlaceholders` because OpenClaw scrubs
+ * env when spawning MCP subprocesses (verified via the drive shim
+ * regression on pi2 2026-05-11). The API key is NOT baked into the
+ * source — it lives in a sibling `secret.json` file written with
+ * mode 0o600 so the readable-to-world shim source stays free of
+ * secrets and mcporter.json (mode 0o644) does too. Env fallbacks are
+ * kept only for hand-running during development.
+ *
+ * Stdio framing: NDJSON JSON-RPC 2.0 (MCP standard). Pure Node
+ * builtins, no npm install needed inside the runtime image.
+ */
+export const ANYTHINGLLM_MCP_SHIM_VERSION = "0.2.0";
+/** Filename for the sibling 0o600 secret file (path resolved at runtime). */
+export const ANYTHINGLLM_SHIM_SECRET_FILENAME = "secret.json";
+export const ANYTHINGLLM_MCP_SHIM_SOURCE = `#!/usr/bin/env node
+// jishushell-anythingllm-shim — generated, do not edit by hand.
+// Source: src/services/runtime/mcp-shims/anythingllm-shim.ts
+
+const path = require("node:path");
+const fs   = require("node:fs");
+
+const BASE_URL_LIT  = "__JS_BASE_URL__";
+const WORKSPACE_LIT = "__JS_WORKSPACE__";
+
+// API key comes from a 0o600 sibling file so neither the shim source
+// (mode 0o644) nor mcporter.json (also 0o644) carries the plaintext key.
+function loadApiKey() {
+  try {
+    const secretPath = path.join(__dirname, ${JSON.stringify(ANYTHINGLLM_SHIM_SECRET_FILENAME)});
+    const raw = fs.readFileSync(secretPath, "utf-8");
+    const j = JSON.parse(raw);
+    if (j && typeof j.apiKey === "string" && j.apiKey) return j.apiKey;
+  } catch (_) { /* fall through to env fallback */ }
+  return process.env.ANYTHINGLLM_API_KEY || "";
+}
+
+const BASE_URL  = (BASE_URL_LIT.startsWith("__JS_") ? (process.env.ANYTHINGLLM_BASE_URL || "") : BASE_URL_LIT).replace(/\\/+$/, "");
+const API_KEY   = loadApiKey();
+const WORKSPACE = WORKSPACE_LIT.startsWith("__JS_") ? (process.env.ANYTHINGLLM_WORKSPACE || "default") : WORKSPACE_LIT;
+
+function envCheck() {
+  const missing = [];
+  if (!BASE_URL) missing.push("ANYTHINGLLM_BASE_URL");
+  if (!API_KEY)  missing.push("ANYTHINGLLM_API_KEY");
+  if (missing.length) {
+    throw new Error("anythingllm-shim: missing env: " + missing.join(", "));
+  }
+}
+
+async function kbSearch(query) {
+  envCheck();
+  // mode=query forces "answer only from KB" — what we want for a tool call.
+  // Workspace endpoint surfaces \`sources\` array natively for citation.
+  const r = await fetch(BASE_URL + "/api/v1/workspace/" + WORKSPACE + "/chat", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": "Bearer " + API_KEY,
+    },
+    body: JSON.stringify({ message: query, mode: "query" }),
+  });
+  if (!r.ok) {
+    const txt = await r.text();
+    throw new Error("workspace chat " + r.status + ": " + txt.slice(0, 400));
+  }
+  const j = await r.json();
+  return {
+    answer: j.textResponse || "(no answer)",
+    sources: Array.isArray(j.sources) ? j.sources : [],
+  };
+}
+
+// kb_ingest — read a host-side file and push it into AnythingLLM, then
+// embed into the workspace. The agent gets the absolute path via
+// drive_resolve_local_path, so this is a thin "upload + embed" wrapper.
+//
+// AnythingLLM endpoints used:
+//   POST /api/v1/document/upload       — multipart, returns documents[]
+//                                        with .location strings
+//   POST /api/v1/workspace/{slug}/update-embeddings
+//                                      — body: { adds: [location, ...] }
+//
+// We intentionally don't use AnythingLLM's own \`addToWorkspaces\` query
+// param on /upload — it returns success but doesn't always trigger
+// embedding on first call (verified empirically on 1.7.4); explicit
+// /update-embeddings is the reliable path.
+async function kbIngest(absPath, workspace) {
+  envCheck();
+  const fs = require("node:fs");
+  const path = require("node:path");
+  if (!absPath || typeof absPath !== "string") {
+    throw new Error("kb_ingest: missing 'path' argument");
+  }
+  if (!fs.existsSync(absPath)) throw new Error("kb_ingest: file not found: " + absPath);
+  const stat = fs.statSync(absPath);
+  if (!stat.isFile()) throw new Error("kb_ingest: not a regular file: " + absPath);
+  const ws = workspace || WORKSPACE;
+  const filename = path.basename(absPath);
+  const buf = fs.readFileSync(absPath);
+
+  // Browser-style FormData is available since Node 18 globally.
+  const fd = new FormData();
+  // Blob with simple application/octet-stream is fine — AnythingLLM sniffs
+  // type from the filename extension server-side.
+  fd.append("file", new Blob([buf]), filename);
+
+  const upRes = await fetch(BASE_URL + "/api/v1/document/upload", {
+    method: "POST",
+    headers: { "Authorization": "Bearer " + API_KEY },
+    body: fd,
+  });
+  if (!upRes.ok) {
+    const txt = await upRes.text();
+    throw new Error("upload " + upRes.status + ": " + txt.slice(0, 400));
+  }
+  const upJson = await upRes.json();
+  if (upJson.error) throw new Error("upload error: " + upJson.error);
+  const docs = Array.isArray(upJson.documents) ? upJson.documents : [];
+  if (docs.length === 0) throw new Error("upload returned no documents");
+
+  // Each doc has \`.location\` like "custom-documents/<filename>-<uuid>.json"
+  // — that is the string /update-embeddings expects in adds[].
+  const adds = docs.map((d) => d.location).filter(Boolean);
+  if (adds.length === 0) throw new Error("uploaded docs missing location field");
+
+  const embRes = await fetch(BASE_URL + "/api/v1/workspace/" + ws + "/update-embeddings", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": "Bearer " + API_KEY,
+    },
+    body: JSON.stringify({ adds, deletes: [] }),
+  });
+  if (!embRes.ok) {
+    const txt = await embRes.text();
+    throw new Error("embed " + embRes.status + ": " + txt.slice(0, 400));
+  }
+
+  return { filename, sizeBytes: stat.size, workspace: ws, locations: adds };
+}
+
+function fmtResult(res) {
+  let out = res.answer;
+  if (res.sources.length) {
+    const seen = new Set();
+    const lines = [];
+    for (const s of res.sources) {
+      const key = s.title || s.url || s.docId || "?";
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const scoreStr = s.score != null ? " [score " + Number(s.score).toFixed(2) + "]" : "";
+      lines.push("- " + key + scoreStr);
+      if (lines.length >= 5) break;
+    }
+    if (lines.length) out += "\\n\\n--- 引用 ---\\n" + lines.join("\\n");
+  }
+  return out;
+}
+
+const TOOLS = [
+  {
+    name: "kb_search",
+    description: "Search the user's knowledge base (uploaded docs / manuals / PDFs / notes) for an answer. Use whenever the user asks something likely to be answered by their uploaded documents. Returns the answer text plus up to 5 cited source files. DO NOT call for greetings, code generation, math, real-time queries, or NAS file operations (those go to drive_*).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "The user question, in their original language" },
+      },
+      required: ["query"],
+    },
+  },
+  {
+    name: "kb_ingest",
+    description: "Push a host-side file into the user's knowledge base and embed it so future kb_search calls can find it. Use when the user says \\"加进知识库 / index this / add to KB / 学习这份资料\\" about a file already on disk. Workflow: drive_resolve_local_path to get the absolute path, then kb_ingest with that path. Returns filename + size + workspace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Absolute host path to the file (from drive_resolve_local_path)" },
+        workspace: { type: "string", description: "Optional workspace slug; defaults to the panel-wired workspace" },
+      },
+      required: ["path"],
+    },
+  },
+];
+
+function reply(id, result, error) {
+  const msg = { jsonrpc: "2.0", id };
+  if (error) msg.error = { code: -32603, message: error.message || String(error) };
+  else msg.result = result;
+  process.stdout.write(JSON.stringify(msg) + "\\n");
+}
+
+async function handle(req) {
+  const { id, method, params } = req;
+  try {
+    if (method === "initialize") {
+      reply(id, {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "anythingllm-shim", version: ${JSON.stringify(ANYTHINGLLM_MCP_SHIM_VERSION)} },
+      });
+    } else if (method === "tools/list") {
+      reply(id, { tools: TOOLS });
+    } else if (method === "tools/call") {
+      const tool = params?.name;
+      if (tool === "kb_search") {
+        const query = params?.arguments?.query;
+        if (!query) throw new Error("kb_search: missing 'query' argument");
+        const result = await kbSearch(query);
+        reply(id, { content: [{ type: "text", text: fmtResult(result) }] });
+      } else if (tool === "kb_ingest") {
+        const a = params?.arguments || {};
+        const result = await kbIngest(a.path, a.workspace);
+        reply(id, { content: [{ type: "text", text:
+          "✅ 已加入知识库: " + result.filename +
+          " (" + result.sizeBytes + " bytes, workspace=" + result.workspace + ")" +
+          "\\n   embeddings 处理中，几秒后 kb_search 即可命中。"
+        }] });
+      } else {
+        throw new Error("unknown tool: " + tool);
+      }
+    } else if (method === "notifications/initialized") {
+      // no reply for notifications
+    } else {
+      reply(id, null, new Error("method not implemented: " + method));
+    }
+  } catch (e) {
+    reply(id, null, e);
+  }
+}
+
+let inbuf = "";
+process.stdin.setEncoding("utf-8");
+process.stdin.on("data", (chunk) => {
+  inbuf += chunk;
+  let idx;
+  while ((idx = inbuf.indexOf("\\n")) >= 0) {
+    const line = inbuf.slice(0, idx).trim();
+    inbuf = inbuf.slice(idx + 1);
+    if (!line) continue;
+    let req;
+    try { req = JSON.parse(line); } catch { continue; }
+    void handle(req);
+  }
+});
+process.stdin.on("end", () => process.exit(0));
+`;
+/**
+ * Substitute baked-in NON-SECRET values into the shim source.
+ * Same pattern as substituteDriveShimPlaceholders — done at install
+ * time because OpenClaw scrubs env on MCP subprocess spawn, so the
+ * env-fallback inside the template is unreliable in production.
+ *
+ * The API key is intentionally NOT baked in. Write it to a sibling
+ * file named `ANYTHINGLLM_SHIM_SECRET_FILENAME` (mode 0o600) and the
+ * shim will load it at startup.
+ *
+ * Placeholders use `__JS_*__` so they grep cleanly.
+ */
+export function substituteAnythingllmShimPlaceholders(params) {
+    const escapeStr = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    return ANYTHINGLLM_MCP_SHIM_SOURCE
+        .replace(/__JS_BASE_URL__/g, escapeStr(params.baseUrl))
+        .replace(/__JS_WORKSPACE__/g, escapeStr(params.workspace || "default"));
+}
+//# sourceMappingURL=anythingllm-shim.js.map

package/dist/services/runtime/mcp-shims/anythingllm-shim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anythingllm-shim.js","sourceRoot":"","sources":["../../../../src/services/runtime/mcp-shims/anythingllm-shim.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,CAAC,MAAM,4BAA4B,GAAG,OAAO,CAAC;AACpD,6EAA6E;AAC7E,MAAM,CAAC,MAAM,gCAAgC,GAAG,aAAa,CAAC;AAE9D,MAAM,CAAC,MAAM,2BAA2B,GAAG;;;;;;;;;;;;;;8CAcG,IAAI,CAAC,SAAS,CAAC,gCAAgC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DA2KnC,IAAI,CAAC,SAAS,CAAC,4BAA4B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CtG,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,qCAAqC,CACnD,MAA8C;IAE9C,MAAM,SAAS,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC/E,OAAO,2BAA2B;SAC/B,OAAO,CAAC,kBAAkB,EAAE,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;SACtD,OAAO,CAAC,mBAAmB,EAAE,SAAS,CAAC,MAAM,CAAC,SAAS,IAAI,SAAS,CAAC,CAAC,CAAC;AAC5E,CAAC"}

package/dist/services/runtime/mcp-shims/drive-shim.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Drive MCP shim — exposes the panel's file + organize API to the
+ * agent inside the OpenClaw container (M1 W1.6).
+ *
+ * Why a shim, not a direct MCP server in panel:
+ *   - Panel and agent run in different processes (and often different
+ *     containers). Stdio MCP is the cheapest contract — the container
+ *     already runs node, and `mcporter.json` already wires shim
+ *     stdio servers via `command/args`.
+ *   - The shim translates JSON-RPC tool calls into HTTP calls back
+ *     to the panel via `host.docker.internal:8090`, authenticated
+ *     with the per-host internal token (`X-Jishushell-Internal-Token`)
+ *     plus the per-instance id (`X-Jishushell-Instance`).
+ *
+ * Tool surface (matches panel REST one-to-one):
+ *   drive_list           → GET    /api/files
+ *   drive_read_preview   → GET    /api/files/preview
+ *   drive_quota          → GET    /api/files/quota
+ *   drive_mkdir          → POST   /api/files/mkdir
+ *   drive_organize_scan  → POST   /api/files/organize/scan
+ *   drive_organize_apply → PUT    /api/files/organize/batches/:id/apply
+ *   drive_organize_revert → POST  /api/files/organize/batches/:id/revert
+ *   drive_search        → GET    /api/files/search
+ *   drive_get_meta      → GET    /api/files/meta
+ *   drive_set_meta      → PUT    /api/files/meta
+ *   drive_reindex       → POST   /api/files/reindex
+ *   drive_resolve_local_path → GET /api/files/resolve  (v0.4 — IM-plugin bridge)
+ *   drive_write_binary  → PUT    /api/files               (v0.4 — base64 body)
+ *
+ * The user-facing chat experience this enables:
+ *   user: "整理一下 inbox 里的发票"
+ *   agent → drive_organize_scan({ path: "inbox" })
+ *   agent → drive_organize_apply({ batch_id, selected_ids: [...] })
+ *   agent: "✅ 整理了 8 张发票到 finance/2026/05/, 30 秒内可撤销"
+ *
+ * Stdio framing: NDJSON JSON-RPC 2.0 (MCP standard). Pure Node
+ * builtins — no npm install needed inside the runtime image.
+ */
+export declare const DRIVE_MCP_SHIM_VERSION = "0.4.0";
+export declare const DRIVE_MCP_SHIM_SOURCE: string;
+/**
+ * Bake per-instance values into the shim template. Returns the source to
+ * write to disk. Must be called before writing because OpenClaw scrubs
+ * env when spawning MCP subprocesses, so the env-based fallback in the
+ * template is unreliable in production.
+ *
+ * Placeholders use non-JS-identifier marker `__JS_*__` so they grep cleanly
+ * and never collide with real code paths.
+ */
+export declare function substituteDriveShimPlaceholders(params: {
+    panelUrl: string;
+    token: string;
+    instanceId: string;
+}): string;