tesseract-agent 0.11.39 → 0.11.41

package/dist-bundle/tesseract-mcp-proxy.js

@@ -0,0 +1,371 @@
+import { createRequire as __cr } from 'module';
+import { dirname as __dn } from 'path';
+import { fileURLToPath as __fu } from 'url';
+const require = __cr(import.meta.url);
+const __dirname = __dn(__fu(import.meta.url));
+
+// ../../packages/shared/dist/base-paths.js
+import { homedir, tmpdir } from "node:os";
+import { join, resolve, sep } from "node:path";
+import { readFileSync } from "node:fs";
+var STARTUP_CWD = resolve(process.cwd());
+var USER_HOME = homedir();
+var TEMP_DIR = tmpdir();
+function readXdgUserDirs(home) {
+  const out = {};
+  try {
+    const cfg = process.env.XDG_CONFIG_HOME || join(home, ".config");
+    for (const line of readFileSync(join(cfg, "user-dirs.dirs"), "utf-8").split("\n")) {
+      const m = /^\s*(XDG_[A-Z]+_DIR)\s*=\s*"(.*)"\s*$/.exec(line);
+      if (!m)
+        continue;
+      out[m[1]] = m[2].replace(/^\$HOME\b/, home);
+    }
+  } catch {
+  }
+  return out;
+}
+function deriveSystemDirs(home) {
+  if (process.platform === "linux") {
+    const xdg = readXdgUserDirs(home);
+    return {
+      documents: xdg.XDG_DOCUMENTS_DIR || join(home, "Documents"),
+      downloads: xdg.XDG_DOWNLOAD_DIR || join(home, "Downloads"),
+      desktop: xdg.XDG_DESKTOP_DIR || join(home, "Desktop"),
+      pictures: xdg.XDG_PICTURES_DIR || join(home, "Pictures"),
+      videos: xdg.XDG_VIDEOS_DIR || join(home, "Videos"),
+      music: xdg.XDG_MUSIC_DIR || join(home, "Music")
+    };
+  }
+  return {
+    documents: join(home, "Documents"),
+    downloads: join(home, "Downloads"),
+    desktop: join(home, "Desktop"),
+    pictures: join(home, "Pictures"),
+    videos: process.platform === "win32" ? join(home, "Videos") : join(home, "Movies"),
+    music: join(home, "Music")
+  };
+}
+var systemDirs = deriveSystemDirs(USER_HOME);
+function expandTilde(p) {
+  if (p === "~")
+    return USER_HOME;
+  if (p.startsWith("~/") || p.startsWith("~\\"))
+    return join(USER_HOME, p.slice(2));
+  return p;
+}
+function memoEnvRoot() {
+  const memo = /* @__PURE__ */ new Map();
+  return (envVars, fallback) => {
+    const names = Array.isArray(envVars) ? envVars : [envVars];
+    const memoKey = names.join("|");
+    const hit = memo.get(memoKey);
+    if (hit !== void 0)
+      return hit;
+    const raw = names.map((n) => process.env[n]).find((v) => v && v.trim());
+    const value = raw ? resolve(STARTUP_CWD, expandTilde(raw.trim())) : fallback();
+    if (!peeking)
+      memo.set(memoKey, value);
+    return value;
+  };
+}
+var envRoot = memoEnvRoot();
+var peeking = false;
+var TESSERACT_HOME_ENV_VARS = ["TESSERACT_HOMEDIR", "CCB_TESSERACT_DIR"];
+function tesseractHome() {
+  return envRoot([...TESSERACT_HOME_ENV_VARS], () => join(USER_HOME, ".tesseract"));
+}
+function homeDaemonDir() {
+  return join(tesseractHome(), "daemon");
+}
+function daemonDir() {
+  return envRoot(["TESSERACT_DAEMON_DIR", "CCB_DAEMON_DIR"], homeDaemonDir);
+}
+
+// ../host-daemon/src/tesseract-mcp-proxy.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { createInterface } from "node:readline";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+var DEBUG = process.env.CCB_MCP_PROXY_DEBUG === "1";
+function logErr(...a) {
+  try {
+    process.stderr.write("[tesseract-mcp-proxy] " + a.map((x) => x instanceof Error ? x.message : typeof x === "string" ? x : JSON.stringify(x)).join(" ") + "\n");
+  } catch {
+  }
+}
+function portFilePath() {
+  return process.env.TESSERACT_MCP_PORT_FILE?.trim() || join2(daemonDir(), "mcp-endpoint.json");
+}
+function loadEndpoint() {
+  const url = process.env.TESSERACT_MCP_URL?.trim();
+  if (url) return { url, token: null };
+  try {
+    const o = JSON.parse(readFileSync2(portFilePath(), "utf-8"));
+    return o.port && o.token ? { url: `http://127.0.0.1:${o.port}`, token: o.token } : null;
+  } catch {
+    return null;
+  }
+}
+var OWN_HEADERS = /* @__PURE__ */ new Set(["content-type", "accept", "content-length", "host", "connection", "transfer-encoding", "mcp-session-id", "mcp-protocol-version"]);
+function extraHeaders() {
+  const raw = process.env.TESSERACT_MCP_HEADERS?.trim();
+  if (!raw) return {};
+  try {
+    const o = JSON.parse(raw);
+    if (!o || typeof o !== "object" || Array.isArray(o)) throw new Error("not a JSON object");
+    const out = {};
+    for (const [k, v] of Object.entries(o)) {
+      if (typeof v === "string" && !OWN_HEADERS.has(k.toLowerCase())) out[k.toLowerCase()] = v;
+    }
+    return out;
+  } catch (e) {
+    logErr("TESSERACT_MCP_HEADERS ignored \u2014", e);
+    return {};
+  }
+}
+var EXTRA_HEADERS = extraHeaders();
+var CALL_DEADLINE_MS = 24 * 60 * 60 * 1e3;
+function writeLine(obj) {
+  process.stdout.write(JSON.stringify(obj) + "\n");
+}
+function replyErrorTo(id, message) {
+  if (id !== void 0 && id !== null) writeLine({ jsonrpc: "2.0", id, error: { code: -32e3, message } });
+}
+var isRequest = (m) => typeof m.method === "string" && m.id !== void 0 && m.id !== null;
+var idKey = (id) => JSON.stringify(id);
+var sessionId = null;
+var protocolVersion = null;
+var initLine = null;
+function send(url, line, bearer, signal, method = "POST") {
+  const sentSession = !!sessionId;
+  const headers = {
+    ...EXTRA_HEADERS,
+    ...bearer ? { authorization: `Bearer ${bearer}` } : {},
+    // `accept` lists both, as the Streamable HTTP spec asks of a client.
+    "content-type": "application/json",
+    accept: "application/json, text/event-stream",
+    ...sessionId ? { "mcp-session-id": sessionId } : {},
+    ...protocolVersion ? { "mcp-protocol-version": protocolVersion } : {}
+  };
+  const request = new URL(url).protocol === "https:" ? httpsRequest : httpRequest;
+  return new Promise((resolve2, reject) => {
+    const req = request(url, { method, headers, signal }, (res) => {
+      const status = res.statusCode ?? 0;
+      const ok = status >= 200 && status < 300;
+      const sid = res.headers["mcp-session-id"];
+      if (ok && typeof sid === "string" && sid.trim()) sessionId = sid.trim();
+      res.setEncoding("utf8");
+      resolve2({ status, ok, type: String(res.headers["content-type"] ?? ""), sentSession, body: res });
+    });
+    req.on("error", reject);
+    req.end(method === "POST" ? line : void 0);
+  });
+}
+function sseReader(emit) {
+  let buf = "";
+  let data = [];
+  const line = (l) => {
+    if (l === "") {
+      if (data.length) emit(data.join("\n"));
+      data = [];
+      return;
+    }
+    if (l.startsWith(":")) return;
+    const colon = l.indexOf(":");
+    const field = colon < 0 ? l : l.slice(0, colon);
+    let value = colon < 0 ? "" : l.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    if (field === "data") data.push(value);
+  };
+  return {
+    push(chunk) {
+      buf += chunk;
+      for (; ; ) {
+        const m = /\r\n|\n|\r(?!$)/.exec(buf);
+        if (!m) break;
+        line(buf.slice(0, m.index));
+        buf = buf.slice(m.index + m[0].length);
+      }
+    },
+    // A stream that ends mid-event still delivers it: the answer is what the client is waiting for.
+    end() {
+      if (buf) line(buf.replace(/\r$/, ""));
+      buf = "";
+      line("");
+    }
+  };
+}
+async function relay(res, out) {
+  const answered = /* @__PURE__ */ new Set();
+  const each = (text2) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(text2);
+    } catch {
+      if (text2.trim()) logErr("not JSON-RPC \u2014 dropped:", text2.slice(0, 200));
+      return;
+    }
+    for (const m of Array.isArray(parsed) ? parsed : [parsed]) {
+      if (!m || typeof m !== "object") continue;
+      const r = m;
+      if (r.method === void 0 && r.id !== void 0 && r.id !== null) answered.add(idKey(r.id));
+      out(r);
+    }
+  };
+  if (res.type.includes("text/event-stream")) {
+    const sse = sseReader(each);
+    for await (const chunk of res.body) sse.push(chunk);
+    sse.end();
+    return answered;
+  }
+  let text = "";
+  for await (const chunk of res.body) text += chunk;
+  if (text.trim()) each(text.trim());
+  return answered;
+}
+async function refusal(res) {
+  let text = "";
+  try {
+    for await (const chunk of res.body) {
+      text += chunk;
+      if (text.length > 4e3) break;
+    }
+  } catch {
+  }
+  res.body.resume();
+  let detail = "";
+  try {
+    const e = JSON.parse(text).error;
+    const said = typeof e === "string" ? e : e?.message;
+    if (typeof said === "string") detail = said;
+  } catch {
+  }
+  return `Tesseract tool endpoint returned ${res.status}${detail ? `: ${detail}` : "."}`;
+}
+var reopening = null;
+function reopen(url, bearer, signal) {
+  reopening ??= (async () => {
+    if (!initLine) return false;
+    sessionId = null;
+    protocolVersion = null;
+    const init = await send(url, initLine, bearer, signal);
+    if (!init.ok) {
+      init.body.resume();
+      return false;
+    }
+    await relay(init, (m) => {
+      noteProtocol(m);
+    });
+    const note = await send(url, JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }), bearer, signal);
+    note.body.resume();
+    logErr("the server had forgotten this session \u2014 opened again");
+    return true;
+  })().catch(() => false).finally(() => {
+    reopening = null;
+  });
+  return reopening;
+}
+function noteProtocol(m) {
+  const v = m.result?.protocolVersion;
+  if (typeof v === "string" && v) protocolVersion = v;
+}
+async function forward(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return;
+  }
+  const msgs = (Array.isArray(parsed) ? parsed : [parsed]).filter((m) => !!m && typeof m === "object");
+  const msg = Array.isArray(parsed) ? null : msgs[0] ?? null;
+  const replyAll = (message) => {
+    for (const m of msgs) if (isRequest(m)) replyErrorTo(m.id, message);
+  };
+  if (DEBUG) logErr("\u2192", msg?.method ?? "(batch)", "id", String(msg?.id));
+  const ep = loadEndpoint();
+  if (!ep) {
+    logErr(`endpoint not running (no ${portFilePath()}) \u2014 dropping`, msg?.method ?? "?");
+    replyAll("Tesseract is not running, so its tools are unavailable.");
+    return;
+  }
+  const initializing = msg?.method === "initialize" && isRequest(msg);
+  if (initializing) {
+    initLine = line;
+    sessionId = null;
+    protocolVersion = null;
+  }
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), CALL_DEADLINE_MS);
+  const own = process.env.TESSERACT_MCP_TOKEN;
+  const token = own || ep.token;
+  let bearer = token;
+  const post = (b) => send(ep.url, line, b, ac.signal);
+  try {
+    let res = await post(token);
+    if (res.status === 401 && own && ep.token && own !== ep.token) {
+      logErr("the conversation bearer was refused \u2014 continuing on the shared one");
+      res.body.resume();
+      bearer = ep.token;
+      res = await post(bearer);
+    }
+    if (res.status === 404 && res.sentSession && !initializing && initLine) {
+      res.body.resume();
+      if (await reopen(ep.url, bearer, ac.signal)) res = await post(bearer);
+      else {
+        replyAll("The server ended this session, and it could not be opened again.");
+        return;
+      }
+    }
+    if (DEBUG) logErr("\u2190", msg?.method ?? "?", "status", String(res.status), res.type || "(no body type)");
+    if (!res.ok) {
+      replyAll(await refusal(res));
+      return;
+    }
+    const answered = await relay(res, (m) => {
+      if (initializing && msg && m.method === void 0 && idKey(m.id) === idKey(msg.id)) noteProtocol(m);
+      writeLine(m);
+    });
+    for (const m of msgs) if (isRequest(m) && !answered.has(idKey(m.id))) replyErrorTo(m.id, "The tool server sent no answer.");
+  } catch (e) {
+    replyAll(ac.signal.aborted ? "Tesseract tool request timed out." : e instanceof Error ? e.message : String(e));
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function endSession() {
+  const ep = loadEndpoint();
+  if (!sessionId || !ep) return;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), 3e3);
+  try {
+    (await send(ep.url, "", process.env.TESSERACT_MCP_TOKEN || ep.token, ac.signal, "DELETE")).body.resume();
+  } catch {
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var requests = Promise.resolve();
+var notes = Promise.resolve();
+var rl = createInterface({ input: process.stdin });
+rl.on("line", (line) => {
+  if (!line.trim()) return;
+  let call = false;
+  try {
+    const m = JSON.parse(line);
+    call = Array.isArray(m) ? m.some((x) => !!x && typeof x === "object" && isRequest(x)) : !!m && typeof m === "object" && isRequest(m);
+  } catch {
+    return;
+  }
+  const run = () => forward(line).catch((e) => {
+    logErr("dropped a message \u2014", e);
+  });
+  if (call) {
+    const before = notes;
+    requests = Promise.all([requests, before]).then(run);
+  } else notes = notes.then(run);
+});
+rl.on("close", () => {
+  void Promise.all([requests, notes]).then(endSession).finally(() => process.exit(0));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tesseract-agent",
-  "version": "0.11.39",
+  "version": "0.11.41",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public",
@@ -13,8 +13,8 @@
     "dist-bundle"
   ],
   "author": {
-    "name": "Corneliu Maftuleac",
-    "url": "https://x.com/cmaftuleac"
+    "name": "Eightcell Labs, Inc.",
+    "url": "https://tesseract.dev"
   },
   "contributors": [
     "Eightcell Labs, Inc. (https://tesseract.dev)"