jefrichat-mcp 0.49.4 → 0.49.6

package/dist/http.js

@@ -62435,9 +62435,28 @@ var safeSaveName = (p) => {
 var shPathArg = (p) => p.startsWith("~/") ? `"$HOME"${shq(p.slice(1))}` : shq(p);
 var psq = (s) => `'${String(s).replace(/'/g, "''")}'`;
 var psPathArg = (p) => p.startsWith("~/") || p.startsWith("~\\") ? `($HOME + ${psq(p.slice(1))})` : psq(p);
-var isTextyFile = (mime, name) => /^text\/|json|xml|javascript|typescript|markdown|csv|ya?ml|x-sh|toml/i.test(mime) || /\.(md|txt|json|csv|ya?ml|log|ts|tsx|js|jsx|py|rb|go|rs|java|c|h|cpp|sh|sql|toml|env|cfg|ini)$/i.test(name);
+var isTextyFile = (mime, name) => /^text\/|json|xml|javascript|typescript|markdown|csv|ya?ml|x-sh|toml/i.test(mime) || // The extension list matters because stored MIMEs are often octet-stream
+// (the taller-norte.html case: an HTML file fell to the link fallback
+// because .html was missing here — code files must come back READABLE).
+/\.(md|txt|json|csv|ya?ml|log|ts|tsx|js|jsx|mjs|py|rb|go|rs|java|c|h|cpp|hpp|cs|sh|sql|toml|env|cfg|ini|html?|css|scss|less|xml|vue|svelte|php|swift|kt|dart|lua)$/i.test(name);
 var DATAURL_INLINE_MAX = 256 * 1024;
-var dataUrlTooBig = (dataUrl) => dataUrl.length > DATAURL_INLINE_MAX * 1.4 ? `That dataUrl is ~${MB(dataUrl.length * 0.75)} MB decoded \u2014 far past the ${Math.round(DATAURL_INLINE_MAX / 1024)}KB inline limit. NEVER read a local file and base64 it through the model. Call this tool again with the file's PATH \u2014 you'll get a single-use upload command that sends it in seconds.` : null;
+function parseInlineDataUrl(dataUrl) {
+  const malformed = `That dataUrl is malformed \u2014 expected data:<mime>;base64,<canonical base64>. Re-encode the bytes (standard base64, correct padding, no whitespace) and try again \u2014 or pick the input that matches where the file lives (path for the user's machine, fileUrl for a public URL).`;
+  const m = /^data:([^;,]+);base64,([A-Za-z0-9+/]*={0,2})$/.exec(dataUrl);
+  if (!m) return { error: malformed };
+  const payload = m[2];
+  if (payload.length % 4 !== 0) return { error: malformed };
+  const bytes = Buffer.from(payload, "base64");
+  if (bytes.toString("base64") !== payload) return { error: malformed };
+  if (bytes.length > DATAURL_INLINE_MAX)
+    return {
+      error: `That dataUrl is ${MB(bytes.length)} MB decoded \u2014 past the ${Math.round(DATAURL_INLINE_MAX / 1024)}KB inline limit. What to do instead:
+\u2022 file on the USER'S machine \u2192 call again with its \`path\` (you'll get a single-use upload command)
+\u2022 file reachable by URL \u2192 call again with \`fileUrl\`
+\u2022 file in YOUR OWN sandbox (no egress) \u2192 too big to inline: present the file to the user for download, and point them at the upload LINK this tool mints (call it with the file's path if you don't have a link yet) \u2014 they tap it, pick the downloaded file, and it delivers.`
+    };
+  return { mime: m[1], bytes };
+}
 var MINT_LINK_DEADLINE_MS = (() => {
   const n = Number(process.env.MCP_MINT_LINK_DEADLINE_MS);
   return Number.isInteger(n) && n > 0 ? n : 1e4;
@@ -62467,30 +62486,77 @@ async function mintFileLink(hub, token, fileId) {
     clearTimeout(killer);
   }
 }
-var forwardTip = (link2, fileName) => `\u2022 To FORWARD this exact file: to a PERSON call jefri_send_file with to:"<username>", fileUrl:${JSON.stringify(link2)}, fileName:${JSON.stringify(fileName)}; to a GROUP call jefri_send_group_file with groupId:"<id>" and the same fileUrl + fileName. The connector fetches and delivers the ORIGINAL bytes (up to 25 MB).
+var forwardTip = (link2, fileName) => `\u2022 The direct-download link is for the HUMAN to click \u2014 don't fetch it with your own web tool (hosts restrict fetches, and the link expires ~5 min; if it has expired, call jefri_download_file again for a fresh one).
+\u2022 To FORWARD this exact file: to a PERSON call jefri_send_file with to:"<username>", fileUrl:${JSON.stringify(link2)}, fileName:${JSON.stringify(fileName)}; to a GROUP call jefri_send_group_file with groupId:"<id>" and the same fileUrl + fileName. The connector fetches and delivers the ORIGINAL bytes (up to 25 MB).
 `;
-async function remoteUploadCommand(c, ctx, target, path3, caption, where) {
+async function remoteUploadCommand(c, ctx, target, path3, caption, where, signal) {
   const fname = crossBasename(path3);
   const fmime = mimeOf(fname);
   const hub = ctx.serverUrl.replace(/\/$/, "");
   try {
-    const g = await fetch(`${hub}/api/files/grant`, {
-      method: "POST",
-      headers: { authorization: `Bearer ${c.token}`, "content-type": "application/json" },
-      body: JSON.stringify({ ...target.to ? { to: target.to } : { groupId: target.groupId }, fileName: fname, ...caption ? { caption } : {} })
-    });
-    if (g.ok) {
-      const { uploadUrl, expiresInMs } = await g.json();
-      const mins = Math.round((expiresInMs ?? 9e5) / 6e4);
+    const gc = new AbortController();
+    const onHostAbort = () => gc.abort();
+    const gKiller = setTimeout(() => gc.abort(), MINT_LINK_DEADLINE_MS);
+    if (signal) {
+      if (signal.aborted) {
+        clearTimeout(gKiller);
+        throw new Error("cancelled");
+      }
+      signal.addEventListener("abort", onHostAbort, { once: true });
+    }
+    let mins;
+    let uploadUrl;
+    try {
+      const g = await fetch(`${hub}/api/files/grant`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${c.token}`, "content-type": "application/json" },
+        body: JSON.stringify({ ...target.to ? { to: target.to } : { groupId: target.groupId }, fileName: fname, ...caption ? { caption } : {} }),
+        signal: gc.signal
+      });
+      if (!g.ok) {
+        try {
+          await g.body?.cancel();
+        } catch {
+        }
+        throw new Error(`grant service answered ${g.status}`);
+      }
+      const body = await g.json().catch(() => ({}));
+      const parsedUrl = (() => {
+        if (typeof body.uploadUrl !== "string") return null;
+        try {
+          const u = new URL(body.uploadUrl);
+          return (u.protocol === "http:" || u.protocol === "https:") && u.host ? body.uploadUrl : null;
+        } catch {
+          return null;
+        }
+      })();
+      if (!parsedUrl) throw new Error("malformed grant response: uploadUrl");
+      if (typeof body.expiresInMs !== "number" || !Number.isFinite(body.expiresInMs) || body.expiresInMs <= 0)
+        throw new Error("malformed grant response: expiresInMs");
+      uploadUrl = parsedUrl;
+      mins = Math.round(body.expiresInMs / 6e4);
+    } finally {
+      gc.abort();
+      clearTimeout(gKiller);
+      if (signal) signal.removeEventListener("abort", onHostAbort);
+    }
+    {
       return {
-        ok: `This cloud connector can't read your disk \u2014 but here is the fast path. Run this ONE command in the terminal (it uploads AND delivers the file to ${where}):
+        ok: `This cloud connector can't read that path \u2014 two fast paths, pick one:
+
+\u{1F517} EASIEST \u2014 no terminal: have the USER open this link in any browser (phone works) and pick the file; it delivers straight to ${where}:
+${uploadUrl}
+
+\u{1F4BB} Or run this ONE command on a machine that HAS the file and has internet (the user's terminal \u2014 NOT a sandboxed assistant environment without egress):
 
 curl -sS -X POST ${shq(uploadUrl)} -H ${shq(`Content-Type: ${fmime}`)} --data-binary @${shPathArg(path3)}
 
 Windows PowerShell instead:
 Invoke-RestMethod -Uri ${psq(uploadUrl)} -Method Post -ContentType ${psq(fmime)} -InFile ${psPathArg(path3)}
 
-The link is single-use and expires in ${mins} min; the file name and caption are already attached to it. Run it now, then confirm delivery from its JSON response ({"ok":true,...}). Do NOT read the file and base64 it through dataUrl \u2014 that is minutes of model output and fails over ~3MB.`
+The link is single-use and expires in ${mins} min; the file name and caption are already attached to it. Run it now, then confirm delivery from its JSON response ({"ok":true,...}).
+\u26A0\uFE0F If YOU are a sandboxed assistant with no network egress and the file lives in YOUR sandbox: this command cannot run anywhere that can see the file. Instead \u2014 if the file is 256KB or less, call this tool again with dataUrl (base64 it) + fileName; if larger, PRESENT the file to the user for download and tell them to open the LINK ABOVE and pick the downloaded file. Do NOT paste this curl into your own shell.
+Never base64 anything over 256KB through dataUrl \u2014 that is minutes of model output and it will be refused.`
       };
     }
   } catch {
@@ -62500,7 +62566,7 @@ The link is single-use and expires in ${mins} min; the file name and caption are
   const q = (target.to ? `to=${encodeURIComponent(target.to)}` : `groupId=${encodeURIComponent(target.groupId)}`) + `&fileName=${encodeURIComponent(fname)}` + (caption ? `&caption=${encodeURIComponent(caption)}` : "");
   const cmd = `curl -s -X POST ${shq(`${hub}/api/files?${q}`)} -H "Authorization: Bearer $JEFRI_TOKEN" -H ${shq(`Content-Type: ${fmime}`)} --data-binary @${shPathArg(path3)}`;
   return {
-    fail: `This is the cloud connector, so it can't read "${fname}" off your computer, and the upload-link service didn't answer. Options:
+    fail: `This is the cloud connector, so it can't read "${fname}" from that path, and the upload-link service didn't answer. Options:
 
 \u2705 open the Jefri Chat web app and DRAG "${fname}" into the chat with ${where}:
    ${dropLink}
@@ -62508,7 +62574,7 @@ The link is single-use and expires in ${mins} min; the file name and caption are
 \u2014 or from a terminal (set JEFRI_TOKEN from the app's Connect dialog first):
 ${cmd}
 
-Do NOT base64 the file through dataUrl \u2014 that streams megabytes through the model and fails over ~3MB.`
+Sandboxed assistant holding the file yourself? 256KB or less: send it via dataUrl + fileName; larger: present the file to the user for download and retry this tool with the path \u2014 the minted upload link lets them pick the downloaded file. Never base64 anything over 256KB through dataUrl.`
   };
 }
 async function fetchHistory(c, convId) {
@@ -62534,7 +62600,22 @@ var MIME = {
   ".txt": "text/plain",
   ".md": "text/markdown",
   ".json": "application/json",
-  ".zip": "application/zip"
+  ".zip": "application/zip",
+  // Web/code types (the taller-norte.html case): without these an .html send
+  // shipped as octet-stream, so the web app couldn't render it and receivers
+  // saw "binary". Bytes always travelled fine — the LABEL was wrong.
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".ts": "text/plain",
+  ".tsx": "text/plain",
+  ".csv": "text/csv",
+  ".xml": "application/xml",
+  ".yaml": "text/yaml",
+  ".yml": "text/yaml",
+  ".log": "text/plain"
 };
 var mimeOf = (name) => MIME[np3.extname(name).toLowerCase()] ?? "application/octet-stream";
 function fmtTime(iso) {
@@ -63474,25 +63555,106 @@ ${fp}`);
       return ok3(`Sent private E2E group file.`);
     })
   );
+  if (!ctx.local) server2.registerTool(
+    "jefri_upload_link",
+    {
+      title: "Get an upload link (any file up to 100 MB, full quality)",
+      description: "Get a ONE-TAP UPLOAD LINK to send files or images \u2014 up to 5 PER LINK via `fileNames`, up to 100 MB each, FULL quality, no base64, no compression, no path needed. ALWAYS PREFER THIS for images and for files in your sandbox or on the user's device \u2014 the ONE exception: files \u2264256KB (already held OR readable in your sandbox \u2014 PDFs, CSVs, code, small images) go straight through jefri_send_file's dataUrl automatically, no link needed. One cheap call, then hand the user the link \u2014 they open it (phone works), pick the file, and it delivers to the recipient automatically. Give `to` (a username) or `groupId`, plus the `fileName` the delivery should carry. The link is single-use and expires in ~15 minutes; mint a fresh one any time. If the file lives in YOUR sandbox, present it to the user for download first so they can pick it at the link. NEVER stream file bytes through plain output (base64/pixel data) \u2014 that burns the user's tokens. The ONE sanctioned carrier is a \u2264256KB `dataUrl` TOOL ARGUMENT via jefri_send_file (near the cap it may still strain output limits \u2014 then use this link); anything larger only ever travels as this link.",
+      inputSchema: {
+        to: external_exports.string().optional().describe("recipient username (or use groupId)"),
+        groupId: external_exports.string().optional().describe("group id (from jefri_groups) instead of `to`"),
+        fileName: external_exports.string().optional().describe("the name the delivered file should carry, e.g. photo.png (single file)"),
+        fileNames: external_exports.array(external_exports.string()).optional().describe('for a MULTI-file link (2\u20135): the delivery names in order, e.g. ["foto-1.jpg","foto-2.jpg"] \u2014 one link, the user picks them all'),
+        caption: external_exports.string().optional().describe("optional text caption delivered with the file")
+      }
+    },
+    async (args, extra) => withClient(async (c) => {
+      const to = typeof args.to === "string" && args.to.trim() ? args.to.trim() : void 0;
+      const groupId = typeof args.groupId === "string" && args.groupId.trim() ? args.groupId.trim() : void 0;
+      if (!to && !groupId) return fail("give `to` (a username) or `groupId`");
+      if (to && groupId) return fail("give either `to` or `groupId`, not both");
+      const names = Array.isArray(args.fileNames) ? args.fileNames.map((n) => String(n ?? "").trim()).filter(Boolean).slice(0, 5) : [];
+      const fileName = String(args.fileName ?? "").trim();
+      if (!fileName && names.length === 0) return fail("give `fileName` (one file) or `fileNames` (2\u20135 files) \u2014 deliveries carry these names");
+      if (Array.isArray(args.fileNames) && args.fileNames.length > 5)
+        return fail("a link carries at most 5 files \u2014 mint another link for more");
+      const hub = ctx.serverUrl.replace(/\/$/, "");
+      const gc = new AbortController();
+      const onHostAbort = () => gc.abort();
+      const gKiller = setTimeout(() => gc.abort(), MINT_LINK_DEADLINE_MS);
+      const signal = extra?.signal;
+      if (signal) {
+        if (signal.aborted) {
+          clearTimeout(gKiller);
+          return fail("cancelled");
+        }
+        signal.addEventListener("abort", onHostAbort, { once: true });
+      }
+      try {
+        const g = await fetch(`${hub}/api/files/grant`, {
+          method: "POST",
+          headers: { authorization: `Bearer ${c.token}`, "content-type": "application/json" },
+          body: JSON.stringify({ ...to ? { to } : { groupId }, ...names.length ? { fileNames: names } : { fileName }, ...args.caption ? { caption: args.caption } : {} }),
+          signal: gc.signal
+        });
+        if (!g.ok) {
+          try {
+            await g.body?.cancel();
+          } catch {
+          }
+          return fail(`the upload-link service answered ${g.status} \u2014 try again shortly. Real fallbacks while it's down: a public URL \u2192 jefri_send_file with fileUrl; otherwise present/download the file and DRAG it into the Jefri Chat web app.`);
+        }
+        const body = await g.json().catch(() => ({}));
+        const parsedUrl = (() => {
+          const raw = names.length ? body.batchUrl : body.uploadUrl;
+          if (typeof raw !== "string") return null;
+          try {
+            const u = new URL(raw);
+            return (u.protocol === "http:" || u.protocol === "https:") && u.host ? raw : null;
+          } catch {
+            return null;
+          }
+        })();
+        if (!parsedUrl || typeof body.expiresInMs !== "number" || !Number.isFinite(body.expiresInMs) || body.expiresInMs <= 0)
+          return fail("the upload-link service answered malformed data \u2014 try again shortly. Real fallbacks: a public URL \u2192 jefri_send_file with fileUrl; otherwise present/download the file and DRAG it into the Jefri Chat web app.");
+        const mins = Math.round(body.expiresInMs / 6e4);
+        const where = to ? `@${safeHandle(to)}` : "the group";
+        const delivers = names.length ? `${names.length} files: ${names.map((n) => `\u{1F4CE} ${n}`).join(", ")}` : `\u{1F4CE} ${fileName}`;
+        return ok3(
+          `\u{1F517} One-tap upload link for ${where} (delivers ${delivers}; valid ~${mins} min, single-use):
+${parsedUrl}
+
+SAY THIS to the user (adapt their language): "Here's your upload link \u2014 open it and pick the ${names.length ? "files" : "file"}; ${names.length ? "they deliver" : "it delivers"} to ${where} automatically at full quality: ${parsedUrl}" If the file is in YOUR sandbox, present it for download first so they can pick the downloaded copy. Do NOT open the link yourself and do NOT prepare or stream any bytes \u2014 your part is done.`
+        );
+      } catch (e) {
+        return fail(`could not mint the upload link: ${e?.message ?? e} \u2014 try again shortly. Real fallbacks: a public URL \u2192 jefri_send_file with fileUrl; otherwise present/download the file and DRAG it into the Jefri Chat web app.`);
+      } finally {
+        gc.abort();
+        clearTimeout(gKiller);
+        if (signal) signal.removeEventListener("abort", onHostAbort);
+      }
+    })
+  );
   server2.registerTool(
     "jefri_send_file",
     {
       title: "Send a file, PDF, or image",
-      description: "Send a file to another Jefri Chat user/agent \u2014 PDF, image (jpg/png/gif/webp), video (mp4/mov), or any document. ALWAYS give the local file `path` (e.g. ~/Downloads/report.pdf) and an optional `caption` \u2014 even on the remote/cloud connector: there this tool answers with ONE ready-to-run terminal command (a single-use upload link) that sends the file in seconds. NEVER read the file yourself and base64 it into `dataUrl` \u2014 that streams megabytes through the model, takes minutes, and fails over ~3MB; `dataUrl` is ONLY for tiny content you already hold inline (small generated snippets). If you only have a public URL for the file, pass `fileUrl` and the connector fetches the bytes itself.",
+      description: ctx.local ? "Send a file to a Jefri Chat user/agent \u2014 PDF, image, video, any document. On this LOCAL connector, `path` reads the file off disk and sends it DIRECTLY (up to 100 MB) \u2014 always prefer `path`; never read a file into base64 yourself. `dataUrl` + `fileName` is only for small (\u2264256KB) content you generated in-conversation, and `fileUrl` fetches a public URL. Optional `caption` always." : "Send a file to a Jefri Chat user/agent. THE RULE: a file \u2264256KB (check its size first \u2014 PDFs, CSVs, code, small images alike), whether already held as base64 or sitting in your sandbox, \u2192 read it and send NOW via `dataUrl` + `fileName`, automatically, no user step. ANYTHING over 256KB, or that would need TRANSFORMING (compressing, converting, resizing) \u2192 STOP and call jefri_upload_link instead \u2014 never transform. For a file on the USER'S DEVICE, CALL THIS TOOL FIRST with the file's `path` \u2014 even a path this connector cannot read: it answers a one-tap upload LINK the user opens to deliver the file at full quality. NEVER pre-process first: no compressing, no splitting base64 into chunks, no reading/retyping base64 through a viewer \u2014 that wastes many minutes and usually fails; the LINK route needs none of it. Inputs by where the file lives: (1) user's machine \u2192 `path` (also yields a runnable upload command). (2) public URL \u2192 `fileUrl` (connector fetches, \u226425MB). (3) YOUR OWN sandbox (cloud-sandboxed assistant, no egress): up to 100 MB \u2192 `path` for the LINK (present the file for the user to download and pick at the link); \u2264256KB (held OR read from your sandbox) \u2192 `dataUrl` + `fileName`, automatically. Large images: the LINK, full quality \u2014 do not offer to compress. Optional `caption` always.",
       inputSchema: {
         to: external_exports.string().describe("recipient username"),
         path: external_exports.string().optional().describe("local file path, e.g. ~/Downloads/report.pdf"),
         caption: external_exports.string().optional().describe("optional text caption to send with it"),
-        dataUrl: external_exports.string().optional().describe("ONLY for tiny inline content you already hold (max 256KB decoded). NEVER construct this by reading a local file \u2014 pass `path` instead."),
+        dataUrl: external_exports.string().optional().describe("content you HOLD, max 256KB decoded. Two right uses: content you generated in-conversation, or a small file in YOUR OWN sandbox when you are a cloud-sandboxed assistant with no network egress (Claude apps/Cowork) \u2014 there dataUrl is the CORRECT way to send it. Never base64 a file on the USER machine (pass `path` instead), and never anything over 256KB."),
         fileUrl: external_exports.string().optional().describe("alternatively, a public http(s) URL to fetch the file from (e.g. a generated image)"),
         fileName: external_exports.string().optional().describe("file name (used with dataUrl, or to name a fileUrl download)")
       }
     },
     async ({ to, path: path3, caption, dataUrl, fileUrl, fileName }, extra) => withClient(async (c) => {
       let name, mime, url;
+      let inlineBytes = null;
       if (path3) {
         if (!ctx.local) {
-          const r = await remoteUploadCommand(c, ctx, { to }, path3, caption, `@${safeHandle(to)}`);
+          const r = await remoteUploadCommand(c, ctx, { to }, path3, caption, `@${safeHandle(to)}`, extra?.signal);
           return "ok" in r ? ok3(r.ok) : fail(r.fail);
         }
         const abs = resolveLocalFile(path3);
@@ -63504,10 +63666,11 @@ ${fp}`);
         mime = mimeOf(name);
         url = `data:${mime};base64,${buf.toString("base64")}`;
       } else if (dataUrl && fileName) {
-        const tooBig = dataUrlTooBig(dataUrl);
-        if (tooBig) return fail(tooBig);
+        const parsed = parseInlineDataUrl(dataUrl);
+        if ("error" in parsed) return fail(parsed.error);
         name = fileName;
-        mime = dataUrl.match(/^data:([^;]+)/)?.[1] ?? mimeOf(fileName);
+        mime = parsed.mime;
+        inlineBytes = parsed.bytes;
         url = dataUrl;
       } else if (fileUrl) {
         try {
@@ -63517,10 +63680,10 @@ ${fp}`);
         }
       } else {
         return fail(
-          "provide a local file `path`, a `dataUrl` + `fileName` (\u2264256KB), or a public `fileUrl`. If the file only exists INSIDE this chat (attached or generated here), the connector can't see it \u2014 ask the user to save it to their computer first, then call again with that path."
+          "provide a local file `path`, a `dataUrl` + `fileName` (\u2264256KB), or a public `fileUrl`. File in YOUR OWN sandbox (you are a cloud-sandboxed assistant)? \u2264256KB \u2192 base64 it into `dataUrl` + `fileName`; larger \u2192 call again with the file's sandbox `path` to mint a one-tap upload LINK, present the file for download, and have the user open the link and pick it. File attached in this chat that YOU can't read? Ask the user to save it to their computer, then call again with that path."
         );
       }
-      const rawBytes = Buffer.from(url.split(",")[1] ?? "", "base64");
+      const rawBytes = inlineBytes ?? Buffer.from(url.split(",")[1] ?? "", "base64");
       if (rawBytes.length > MAX_UPLOAD_BYTES)
         return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
       if (isStateless(c)) {
@@ -64257,21 +64420,22 @@ Or just upload ${fname} from the agent's page in the web app.`
     "jefri_send_group_file",
     {
       title: "Send a file to a group",
-      description: "Send a file/image to a GROUP by its group id. Give a local file `path` (works on the local/stdio connector), a `dataUrl` + `fileName`, or a public `fileUrl` to fetch (e.g. a generated image). Get the group id from jefri_groups / jefri_inbox.",
+      description: ctx.local ? "Send a file/image to a GROUP by its group id (from jefri_groups / jefri_inbox). On this LOCAL connector, `path` sends the file DIRECTLY off disk (up to 100 MB) \u2014 always prefer `path`; `dataUrl` only for small generated content; `fileUrl` for a public URL." : "Send a file/image to a GROUP by its group id (from jefri_groups / jefri_inbox). For a file on the USER'S DEVICE, CALL FIRST with its `path` \u2014 even one this connector cannot read: you get a one-tap upload LINK for the user. NEVER TRANSFORM (no compressing/splitting/retyping base64 through a viewer). user's device \u2192 `path`; public URL \u2192 `fileUrl`; your OWN sandbox: \u2264256KB (any type) \u2192 read it, send via `dataUrl` + `fileName` automatically; larger \u2192 `path` for the LINK (up to 100 MB).",
       inputSchema: {
         groupId: external_exports.string().describe("the group's id (from jefri_groups or jefri_inbox)"),
         path: external_exports.string().optional().describe("local file path, e.g. ~/Downloads/report.pdf"),
         caption: external_exports.string().optional().describe("optional text caption"),
-        dataUrl: external_exports.string().optional().describe("ONLY for tiny inline content you already hold (max 256KB decoded). NEVER construct this by reading a local file \u2014 pass `path` instead."),
+        dataUrl: external_exports.string().optional().describe("content you HOLD, max 256KB decoded. Two right uses: content you generated in-conversation, or a small file in YOUR OWN sandbox when you are a cloud-sandboxed assistant with no network egress (Claude apps/Cowork) \u2014 there dataUrl is the CORRECT way to send it. Never base64 a file on the USER machine (pass `path` instead), and never anything over 256KB."),
         fileUrl: external_exports.string().optional().describe("alternatively, a public http(s) URL to fetch the file from"),
         fileName: external_exports.string().optional().describe("file name (used with dataUrl, or to name a fileUrl download)")
       }
     },
     async ({ groupId, path: path3, caption, dataUrl, fileUrl, fileName }, extra) => withClient(async (c) => {
       let name, mime, url;
+      let inlineBytes = null;
       if (path3) {
         if (!ctx.local) {
-          const r = await remoteUploadCommand(c, ctx, { groupId }, path3, caption, "the group");
+          const r = await remoteUploadCommand(c, ctx, { groupId }, path3, caption, "the group", extra?.signal);
           return "ok" in r ? ok3(r.ok) : fail(r.fail);
         }
         const abs = resolveLocalFile(path3);
@@ -64281,10 +64445,11 @@ Or just upload ${fname} from the agent's page in the web app.`
         mime = mimeOf(name);
         url = `data:${mime};base64,${buf.toString("base64")}`;
       } else if (dataUrl && fileName) {
-        const tooBig = dataUrlTooBig(dataUrl);
-        if (tooBig) return fail(tooBig);
+        const parsed = parseInlineDataUrl(dataUrl);
+        if ("error" in parsed) return fail(parsed.error);
         name = fileName;
-        mime = dataUrl.match(/^data:([^;]+)/)?.[1] ?? mimeOf(fileName);
+        mime = parsed.mime;
+        inlineBytes = parsed.bytes;
         url = dataUrl;
       } else if (fileUrl) {
         try {
@@ -64294,10 +64459,10 @@ Or just upload ${fname} from the agent's page in the web app.`
         }
       } else {
         return fail(
-          "provide a local file `path`, a `dataUrl` + `fileName` (\u2264256KB), or a public `fileUrl`. If the file only exists INSIDE this chat (attached or generated here), the connector can't see it \u2014 ask the user to save it to their computer first, then call again with that path."
+          "provide a local file `path`, a `dataUrl` + `fileName` (\u2264256KB), or a public `fileUrl`. File in YOUR OWN sandbox (you are a cloud-sandboxed assistant)? \u2264256KB \u2192 base64 it into `dataUrl` + `fileName`; larger \u2192 call again with the file's sandbox `path` to mint a one-tap upload LINK, present the file for download, and have the user open the link and pick it. File attached in this chat that YOU can't read? Ask the user to save it to their computer, then call again with that path."
         );
       }
-      const rawBytes = Buffer.from(url.split(",")[1] ?? "", "base64");
+      const rawBytes = inlineBytes ?? Buffer.from(url.split(",")[1] ?? "", "base64");
       if (rawBytes.length > MAX_UPLOAD_BYTES)
         return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
       if (isStateless(c)) {

package/dist/index.js

@@ -42155,9 +42155,28 @@ var safeSaveName = (p) => {
 var shPathArg = (p) => p.startsWith("~/") ? `"$HOME"${shq(p.slice(1))}` : shq(p);
 var psq = (s) => `'${String(s).replace(/'/g, "''")}'`;
 var psPathArg = (p) => p.startsWith("~/") || p.startsWith("~\\") ? `($HOME + ${psq(p.slice(1))})` : psq(p);
-var isTextyFile = (mime, name) => /^text\/|json|xml|javascript|typescript|markdown|csv|ya?ml|x-sh|toml/i.test(mime) || /\.(md|txt|json|csv|ya?ml|log|ts|tsx|js|jsx|py|rb|go|rs|java|c|h|cpp|sh|sql|toml|env|cfg|ini)$/i.test(name);
+var isTextyFile = (mime, name) => /^text\/|json|xml|javascript|typescript|markdown|csv|ya?ml|x-sh|toml/i.test(mime) || // The extension list matters because stored MIMEs are often octet-stream
+// (the taller-norte.html case: an HTML file fell to the link fallback
+// because .html was missing here — code files must come back READABLE).
+/\.(md|txt|json|csv|ya?ml|log|ts|tsx|js|jsx|mjs|py|rb|go|rs|java|c|h|cpp|hpp|cs|sh|sql|toml|env|cfg|ini|html?|css|scss|less|xml|vue|svelte|php|swift|kt|dart|lua)$/i.test(name);
 var DATAURL_INLINE_MAX = 256 * 1024;
-var dataUrlTooBig = (dataUrl) => dataUrl.length > DATAURL_INLINE_MAX * 1.4 ? `That dataUrl is ~${MB(dataUrl.length * 0.75)} MB decoded \u2014 far past the ${Math.round(DATAURL_INLINE_MAX / 1024)}KB inline limit. NEVER read a local file and base64 it through the model. Call this tool again with the file's PATH \u2014 you'll get a single-use upload command that sends it in seconds.` : null;
+function parseInlineDataUrl(dataUrl) {
+  const malformed = `That dataUrl is malformed \u2014 expected data:<mime>;base64,<canonical base64>. Re-encode the bytes (standard base64, correct padding, no whitespace) and try again \u2014 or pick the input that matches where the file lives (path for the user's machine, fileUrl for a public URL).`;
+  const m = /^data:([^;,]+);base64,([A-Za-z0-9+/]*={0,2})$/.exec(dataUrl);
+  if (!m) return { error: malformed };
+  const payload = m[2];
+  if (payload.length % 4 !== 0) return { error: malformed };
+  const bytes = Buffer.from(payload, "base64");
+  if (bytes.toString("base64") !== payload) return { error: malformed };
+  if (bytes.length > DATAURL_INLINE_MAX)
+    return {
+      error: `That dataUrl is ${MB(bytes.length)} MB decoded \u2014 past the ${Math.round(DATAURL_INLINE_MAX / 1024)}KB inline limit. What to do instead:
+\u2022 file on the USER'S machine \u2192 call again with its \`path\` (you'll get a single-use upload command)
+\u2022 file reachable by URL \u2192 call again with \`fileUrl\`
+\u2022 file in YOUR OWN sandbox (no egress) \u2192 too big to inline: present the file to the user for download, and point them at the upload LINK this tool mints (call it with the file's path if you don't have a link yet) \u2014 they tap it, pick the downloaded file, and it delivers.`
+    };
+  return { mime: m[1], bytes };
+}
 var MINT_LINK_DEADLINE_MS = (() => {
   const n = Number(process.env.MCP_MINT_LINK_DEADLINE_MS);
   return Number.isInteger(n) && n > 0 ? n : 1e4;
@@ -42187,30 +42206,77 @@ async function mintFileLink(hub, token, fileId) {
     clearTimeout(killer);
   }
 }
-var forwardTip = (link2, fileName) => `\u2022 To FORWARD this exact file: to a PERSON call jefri_send_file with to:"<username>", fileUrl:${JSON.stringify(link2)}, fileName:${JSON.stringify(fileName)}; to a GROUP call jefri_send_group_file with groupId:"<id>" and the same fileUrl + fileName. The connector fetches and delivers the ORIGINAL bytes (up to 25 MB).
+var forwardTip = (link2, fileName) => `\u2022 The direct-download link is for the HUMAN to click \u2014 don't fetch it with your own web tool (hosts restrict fetches, and the link expires ~5 min; if it has expired, call jefri_download_file again for a fresh one).
+\u2022 To FORWARD this exact file: to a PERSON call jefri_send_file with to:"<username>", fileUrl:${JSON.stringify(link2)}, fileName:${JSON.stringify(fileName)}; to a GROUP call jefri_send_group_file with groupId:"<id>" and the same fileUrl + fileName. The connector fetches and delivers the ORIGINAL bytes (up to 25 MB).
 `;
-async function remoteUploadCommand(c2, ctx, target, path5, caption, where) {
+async function remoteUploadCommand(c2, ctx, target, path5, caption, where, signal) {
   const fname = crossBasename(path5);
   const fmime = mimeOf(fname);
   const hub = ctx.serverUrl.replace(/\/$/, "");
   try {
-    const g = await fetch(`${hub}/api/files/grant`, {
-      method: "POST",
-      headers: { authorization: `Bearer ${c2.token}`, "content-type": "application/json" },
-      body: JSON.stringify({ ...target.to ? { to: target.to } : { groupId: target.groupId }, fileName: fname, ...caption ? { caption } : {} })
-    });
-    if (g.ok) {
-      const { uploadUrl, expiresInMs } = await g.json();
-      const mins = Math.round((expiresInMs ?? 9e5) / 6e4);
+    const gc = new AbortController();
+    const onHostAbort = () => gc.abort();
+    const gKiller = setTimeout(() => gc.abort(), MINT_LINK_DEADLINE_MS);
+    if (signal) {
+      if (signal.aborted) {
+        clearTimeout(gKiller);
+        throw new Error("cancelled");
+      }
+      signal.addEventListener("abort", onHostAbort, { once: true });
+    }
+    let mins;
+    let uploadUrl;
+    try {
+      const g = await fetch(`${hub}/api/files/grant`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${c2.token}`, "content-type": "application/json" },
+        body: JSON.stringify({ ...target.to ? { to: target.to } : { groupId: target.groupId }, fileName: fname, ...caption ? { caption } : {} }),
+        signal: gc.signal
+      });
+      if (!g.ok) {
+        try {
+          await g.body?.cancel();
+        } catch {
+        }
+        throw new Error(`grant service answered ${g.status}`);
+      }
+      const body = await g.json().catch(() => ({}));
+      const parsedUrl = (() => {
+        if (typeof body.uploadUrl !== "string") return null;
+        try {
+          const u = new URL(body.uploadUrl);
+          return (u.protocol === "http:" || u.protocol === "https:") && u.host ? body.uploadUrl : null;
+        } catch {
+          return null;
+        }
+      })();
+      if (!parsedUrl) throw new Error("malformed grant response: uploadUrl");
+      if (typeof body.expiresInMs !== "number" || !Number.isFinite(body.expiresInMs) || body.expiresInMs <= 0)
+        throw new Error("malformed grant response: expiresInMs");
+      uploadUrl = parsedUrl;
+      mins = Math.round(body.expiresInMs / 6e4);
+    } finally {
+      gc.abort();
+      clearTimeout(gKiller);
+      if (signal) signal.removeEventListener("abort", onHostAbort);
+    }
+    {
       return {
-        ok: `This cloud connector can't read your disk \u2014 but here is the fast path. Run this ONE command in the terminal (it uploads AND delivers the file to ${where}):
+        ok: `This cloud connector can't read that path \u2014 two fast paths, pick one:
+
+\u{1F517} EASIEST \u2014 no terminal: have the USER open this link in any browser (phone works) and pick the file; it delivers straight to ${where}:
+${uploadUrl}
+
+\u{1F4BB} Or run this ONE command on a machine that HAS the file and has internet (the user's terminal \u2014 NOT a sandboxed assistant environment without egress):
 
 curl -sS -X POST ${shq(uploadUrl)} -H ${shq(`Content-Type: ${fmime}`)} --data-binary @${shPathArg(path5)}
 
 Windows PowerShell instead:
 Invoke-RestMethod -Uri ${psq(uploadUrl)} -Method Post -ContentType ${psq(fmime)} -InFile ${psPathArg(path5)}
 
-The link is single-use and expires in ${mins} min; the file name and caption are already attached to it. Run it now, then confirm delivery from its JSON response ({"ok":true,...}). Do NOT read the file and base64 it through dataUrl \u2014 that is minutes of model output and fails over ~3MB.`
+The link is single-use and expires in ${mins} min; the file name and caption are already attached to it. Run it now, then confirm delivery from its JSON response ({"ok":true,...}).
+\u26A0\uFE0F If YOU are a sandboxed assistant with no network egress and the file lives in YOUR sandbox: this command cannot run anywhere that can see the file. Instead \u2014 if the file is 256KB or less, call this tool again with dataUrl (base64 it) + fileName; if larger, PRESENT the file to the user for download and tell them to open the LINK ABOVE and pick the downloaded file. Do NOT paste this curl into your own shell.
+Never base64 anything over 256KB through dataUrl \u2014 that is minutes of model output and it will be refused.`
       };
     }
   } catch {
@@ -42220,7 +42286,7 @@ The link is single-use and expires in ${mins} min; the file name and caption are
   const q = (target.to ? `to=${encodeURIComponent(target.to)}` : `groupId=${encodeURIComponent(target.groupId)}`) + `&fileName=${encodeURIComponent(fname)}` + (caption ? `&caption=${encodeURIComponent(caption)}` : "");
   const cmd = `curl -s -X POST ${shq(`${hub}/api/files?${q}`)} -H "Authorization: Bearer $JEFRI_TOKEN" -H ${shq(`Content-Type: ${fmime}`)} --data-binary @${shPathArg(path5)}`;
   return {
-    fail: `This is the cloud connector, so it can't read "${fname}" off your computer, and the upload-link service didn't answer. Options:
+    fail: `This is the cloud connector, so it can't read "${fname}" from that path, and the upload-link service didn't answer. Options:
 
 \u2705 open the Jefri Chat web app and DRAG "${fname}" into the chat with ${where}:
    ${dropLink}
@@ -42228,7 +42294,7 @@ The link is single-use and expires in ${mins} min; the file name and caption are
 \u2014 or from a terminal (set JEFRI_TOKEN from the app's Connect dialog first):
 ${cmd}
 
-Do NOT base64 the file through dataUrl \u2014 that streams megabytes through the model and fails over ~3MB.`
+Sandboxed assistant holding the file yourself? 256KB or less: send it via dataUrl + fileName; larger: present the file to the user for download and retry this tool with the path \u2014 the minted upload link lets them pick the downloaded file. Never base64 anything over 256KB through dataUrl.`
   };
 }
 async function fetchHistory2(c2, convId) {
@@ -42254,7 +42320,22 @@ var MIME = {
   ".txt": "text/plain",
   ".md": "text/markdown",
   ".json": "application/json",
-  ".zip": "application/zip"
+  ".zip": "application/zip",
+  // Web/code types (the taller-norte.html case): without these an .html send
+  // shipped as octet-stream, so the web app couldn't render it and receivers
+  // saw "binary". Bytes always travelled fine — the LABEL was wrong.
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".ts": "text/plain",
+  ".tsx": "text/plain",
+  ".csv": "text/csv",
+  ".xml": "application/xml",
+  ".yaml": "text/yaml",
+  ".yml": "text/yaml",
+  ".log": "text/plain"
 };
 var mimeOf = (name) => MIME[np4.extname(name).toLowerCase()] ?? "application/octet-stream";
 function fmtTime(iso) {
@@ -43197,25 +43278,106 @@ ${fp}`);
       return ok3(`Sent private E2E group file.`);
     })
   );
+  if (!ctx.local) server2.registerTool(
+    "jefri_upload_link",
+    {
+      title: "Get an upload link (any file up to 100 MB, full quality)",
+      description: "Get a ONE-TAP UPLOAD LINK to send files or images \u2014 up to 5 PER LINK via `fileNames`, up to 100 MB each, FULL quality, no base64, no compression, no path needed. ALWAYS PREFER THIS for images and for files in your sandbox or on the user's device \u2014 the ONE exception: files \u2264256KB (already held OR readable in your sandbox \u2014 PDFs, CSVs, code, small images) go straight through jefri_send_file's dataUrl automatically, no link needed. One cheap call, then hand the user the link \u2014 they open it (phone works), pick the file, and it delivers to the recipient automatically. Give `to` (a username) or `groupId`, plus the `fileName` the delivery should carry. The link is single-use and expires in ~15 minutes; mint a fresh one any time. If the file lives in YOUR sandbox, present it to the user for download first so they can pick it at the link. NEVER stream file bytes through plain output (base64/pixel data) \u2014 that burns the user's tokens. The ONE sanctioned carrier is a \u2264256KB `dataUrl` TOOL ARGUMENT via jefri_send_file (near the cap it may still strain output limits \u2014 then use this link); anything larger only ever travels as this link.",
+      inputSchema: {
+        to: external_exports.string().optional().describe("recipient username (or use groupId)"),
+        groupId: external_exports.string().optional().describe("group id (from jefri_groups) instead of `to`"),
+        fileName: external_exports.string().optional().describe("the name the delivered file should carry, e.g. photo.png (single file)"),
+        fileNames: external_exports.array(external_exports.string()).optional().describe('for a MULTI-file link (2\u20135): the delivery names in order, e.g. ["foto-1.jpg","foto-2.jpg"] \u2014 one link, the user picks them all'),
+        caption: external_exports.string().optional().describe("optional text caption delivered with the file")
+      }
+    },
+    async (args, extra) => withClient(async (c2) => {
+      const to = typeof args.to === "string" && args.to.trim() ? args.to.trim() : void 0;
+      const groupId = typeof args.groupId === "string" && args.groupId.trim() ? args.groupId.trim() : void 0;
+      if (!to && !groupId) return fail("give `to` (a username) or `groupId`");
+      if (to && groupId) return fail("give either `to` or `groupId`, not both");
+      const names = Array.isArray(args.fileNames) ? args.fileNames.map((n) => String(n ?? "").trim()).filter(Boolean).slice(0, 5) : [];
+      const fileName = String(args.fileName ?? "").trim();
+      if (!fileName && names.length === 0) return fail("give `fileName` (one file) or `fileNames` (2\u20135 files) \u2014 deliveries carry these names");
+      if (Array.isArray(args.fileNames) && args.fileNames.length > 5)
+        return fail("a link carries at most 5 files \u2014 mint another link for more");
+      const hub = ctx.serverUrl.replace(/\/$/, "");
+      const gc = new AbortController();
+      const onHostAbort = () => gc.abort();
+      const gKiller = setTimeout(() => gc.abort(), MINT_LINK_DEADLINE_MS);
+      const signal = extra?.signal;
+      if (signal) {
+        if (signal.aborted) {
+          clearTimeout(gKiller);
+          return fail("cancelled");
+        }
+        signal.addEventListener("abort", onHostAbort, { once: true });
+      }
+      try {
+        const g = await fetch(`${hub}/api/files/grant`, {
+          method: "POST",
+          headers: { authorization: `Bearer ${c2.token}`, "content-type": "application/json" },
+          body: JSON.stringify({ ...to ? { to } : { groupId }, ...names.length ? { fileNames: names } : { fileName }, ...args.caption ? { caption: args.caption } : {} }),
+          signal: gc.signal
+        });
+        if (!g.ok) {
+          try {
+            await g.body?.cancel();
+          } catch {
+          }
+          return fail(`the upload-link service answered ${g.status} \u2014 try again shortly. Real fallbacks while it's down: a public URL \u2192 jefri_send_file with fileUrl; otherwise present/download the file and DRAG it into the Jefri Chat web app.`);
+        }
+        const body = await g.json().catch(() => ({}));
+        const parsedUrl = (() => {
+          const raw = names.length ? body.batchUrl : body.uploadUrl;
+          if (typeof raw !== "string") return null;
+          try {
+            const u = new URL(raw);
+            return (u.protocol === "http:" || u.protocol === "https:") && u.host ? raw : null;
+          } catch {
+            return null;
+          }
+        })();
+        if (!parsedUrl || typeof body.expiresInMs !== "number" || !Number.isFinite(body.expiresInMs) || body.expiresInMs <= 0)
+          return fail("the upload-link service answered malformed data \u2014 try again shortly. Real fallbacks: a public URL \u2192 jefri_send_file with fileUrl; otherwise present/download the file and DRAG it into the Jefri Chat web app.");
+        const mins = Math.round(body.expiresInMs / 6e4);
+        const where = to ? `@${safeHandle(to)}` : "the group";
+        const delivers = names.length ? `${names.length} files: ${names.map((n) => `\u{1F4CE} ${n}`).join(", ")}` : `\u{1F4CE} ${fileName}`;
+        return ok3(
+          `\u{1F517} One-tap upload link for ${where} (delivers ${delivers}; valid ~${mins} min, single-use):
+${parsedUrl}
+
+SAY THIS to the user (adapt their language): "Here's your upload link \u2014 open it and pick the ${names.length ? "files" : "file"}; ${names.length ? "they deliver" : "it delivers"} to ${where} automatically at full quality: ${parsedUrl}" If the file is in YOUR sandbox, present it for download first so they can pick the downloaded copy. Do NOT open the link yourself and do NOT prepare or stream any bytes \u2014 your part is done.`
+        );
+      } catch (e) {
+        return fail(`could not mint the upload link: ${e?.message ?? e} \u2014 try again shortly. Real fallbacks: a public URL \u2192 jefri_send_file with fileUrl; otherwise present/download the file and DRAG it into the Jefri Chat web app.`);
+      } finally {
+        gc.abort();
+        clearTimeout(gKiller);
+        if (signal) signal.removeEventListener("abort", onHostAbort);
+      }
+    })
+  );
   server2.registerTool(
     "jefri_send_file",
     {
       title: "Send a file, PDF, or image",
-      description: "Send a file to another Jefri Chat user/agent \u2014 PDF, image (jpg/png/gif/webp), video (mp4/mov), or any document. ALWAYS give the local file `path` (e.g. ~/Downloads/report.pdf) and an optional `caption` \u2014 even on the remote/cloud connector: there this tool answers with ONE ready-to-run terminal command (a single-use upload link) that sends the file in seconds. NEVER read the file yourself and base64 it into `dataUrl` \u2014 that streams megabytes through the model, takes minutes, and fails over ~3MB; `dataUrl` is ONLY for tiny content you already hold inline (small generated snippets). If you only have a public URL for the file, pass `fileUrl` and the connector fetches the bytes itself.",
+      description: ctx.local ? "Send a file to a Jefri Chat user/agent \u2014 PDF, image, video, any document. On this LOCAL connector, `path` reads the file off disk and sends it DIRECTLY (up to 100 MB) \u2014 always prefer `path`; never read a file into base64 yourself. `dataUrl` + `fileName` is only for small (\u2264256KB) content you generated in-conversation, and `fileUrl` fetches a public URL. Optional `caption` always." : "Send a file to a Jefri Chat user/agent. THE RULE: a file \u2264256KB (check its size first \u2014 PDFs, CSVs, code, small images alike), whether already held as base64 or sitting in your sandbox, \u2192 read it and send NOW via `dataUrl` + `fileName`, automatically, no user step. ANYTHING over 256KB, or that would need TRANSFORMING (compressing, converting, resizing) \u2192 STOP and call jefri_upload_link instead \u2014 never transform. For a file on the USER'S DEVICE, CALL THIS TOOL FIRST with the file's `path` \u2014 even a path this connector cannot read: it answers a one-tap upload LINK the user opens to deliver the file at full quality. NEVER pre-process first: no compressing, no splitting base64 into chunks, no reading/retyping base64 through a viewer \u2014 that wastes many minutes and usually fails; the LINK route needs none of it. Inputs by where the file lives: (1) user's machine \u2192 `path` (also yields a runnable upload command). (2) public URL \u2192 `fileUrl` (connector fetches, \u226425MB). (3) YOUR OWN sandbox (cloud-sandboxed assistant, no egress): up to 100 MB \u2192 `path` for the LINK (present the file for the user to download and pick at the link); \u2264256KB (held OR read from your sandbox) \u2192 `dataUrl` + `fileName`, automatically. Large images: the LINK, full quality \u2014 do not offer to compress. Optional `caption` always.",
       inputSchema: {
         to: external_exports.string().describe("recipient username"),
         path: external_exports.string().optional().describe("local file path, e.g. ~/Downloads/report.pdf"),
         caption: external_exports.string().optional().describe("optional text caption to send with it"),
-        dataUrl: external_exports.string().optional().describe("ONLY for tiny inline content you already hold (max 256KB decoded). NEVER construct this by reading a local file \u2014 pass `path` instead."),
+        dataUrl: external_exports.string().optional().describe("content you HOLD, max 256KB decoded. Two right uses: content you generated in-conversation, or a small file in YOUR OWN sandbox when you are a cloud-sandboxed assistant with no network egress (Claude apps/Cowork) \u2014 there dataUrl is the CORRECT way to send it. Never base64 a file on the USER machine (pass `path` instead), and never anything over 256KB."),
         fileUrl: external_exports.string().optional().describe("alternatively, a public http(s) URL to fetch the file from (e.g. a generated image)"),
         fileName: external_exports.string().optional().describe("file name (used with dataUrl, or to name a fileUrl download)")
       }
     },
     async ({ to, path: path5, caption, dataUrl, fileUrl, fileName }, extra) => withClient(async (c2) => {
       let name, mime, url;
+      let inlineBytes = null;
       if (path5) {
         if (!ctx.local) {
-          const r = await remoteUploadCommand(c2, ctx, { to }, path5, caption, `@${safeHandle(to)}`);
+          const r = await remoteUploadCommand(c2, ctx, { to }, path5, caption, `@${safeHandle(to)}`, extra?.signal);
           return "ok" in r ? ok3(r.ok) : fail(r.fail);
         }
         const abs = resolveLocalFile(path5);
@@ -43227,10 +43389,11 @@ ${fp}`);
         mime = mimeOf(name);
         url = `data:${mime};base64,${buf.toString("base64")}`;
       } else if (dataUrl && fileName) {
-        const tooBig = dataUrlTooBig(dataUrl);
-        if (tooBig) return fail(tooBig);
+        const parsed = parseInlineDataUrl(dataUrl);
+        if ("error" in parsed) return fail(parsed.error);
         name = fileName;
-        mime = dataUrl.match(/^data:([^;]+)/)?.[1] ?? mimeOf(fileName);
+        mime = parsed.mime;
+        inlineBytes = parsed.bytes;
         url = dataUrl;
       } else if (fileUrl) {
         try {
@@ -43240,10 +43403,10 @@ ${fp}`);
         }
       } else {
         return fail(
-          "provide a local file `path`, a `dataUrl` + `fileName` (\u2264256KB), or a public `fileUrl`. If the file only exists INSIDE this chat (attached or generated here), the connector can't see it \u2014 ask the user to save it to their computer first, then call again with that path."
+          "provide a local file `path`, a `dataUrl` + `fileName` (\u2264256KB), or a public `fileUrl`. File in YOUR OWN sandbox (you are a cloud-sandboxed assistant)? \u2264256KB \u2192 base64 it into `dataUrl` + `fileName`; larger \u2192 call again with the file's sandbox `path` to mint a one-tap upload LINK, present the file for download, and have the user open the link and pick it. File attached in this chat that YOU can't read? Ask the user to save it to their computer, then call again with that path."
         );
       }
-      const rawBytes = Buffer.from(url.split(",")[1] ?? "", "base64");
+      const rawBytes = inlineBytes ?? Buffer.from(url.split(",")[1] ?? "", "base64");
       if (rawBytes.length > MAX_UPLOAD_BYTES)
         return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
       if (isStateless(c2)) {
@@ -43980,21 +44143,22 @@ Or just upload ${fname} from the agent's page in the web app.`
     "jefri_send_group_file",
     {
       title: "Send a file to a group",
-      description: "Send a file/image to a GROUP by its group id. Give a local file `path` (works on the local/stdio connector), a `dataUrl` + `fileName`, or a public `fileUrl` to fetch (e.g. a generated image). Get the group id from jefri_groups / jefri_inbox.",
+      description: ctx.local ? "Send a file/image to a GROUP by its group id (from jefri_groups / jefri_inbox). On this LOCAL connector, `path` sends the file DIRECTLY off disk (up to 100 MB) \u2014 always prefer `path`; `dataUrl` only for small generated content; `fileUrl` for a public URL." : "Send a file/image to a GROUP by its group id (from jefri_groups / jefri_inbox). For a file on the USER'S DEVICE, CALL FIRST with its `path` \u2014 even one this connector cannot read: you get a one-tap upload LINK for the user. NEVER TRANSFORM (no compressing/splitting/retyping base64 through a viewer). user's device \u2192 `path`; public URL \u2192 `fileUrl`; your OWN sandbox: \u2264256KB (any type) \u2192 read it, send via `dataUrl` + `fileName` automatically; larger \u2192 `path` for the LINK (up to 100 MB).",
       inputSchema: {
         groupId: external_exports.string().describe("the group's id (from jefri_groups or jefri_inbox)"),
         path: external_exports.string().optional().describe("local file path, e.g. ~/Downloads/report.pdf"),
         caption: external_exports.string().optional().describe("optional text caption"),
-        dataUrl: external_exports.string().optional().describe("ONLY for tiny inline content you already hold (max 256KB decoded). NEVER construct this by reading a local file \u2014 pass `path` instead."),
+        dataUrl: external_exports.string().optional().describe("content you HOLD, max 256KB decoded. Two right uses: content you generated in-conversation, or a small file in YOUR OWN sandbox when you are a cloud-sandboxed assistant with no network egress (Claude apps/Cowork) \u2014 there dataUrl is the CORRECT way to send it. Never base64 a file on the USER machine (pass `path` instead), and never anything over 256KB."),
         fileUrl: external_exports.string().optional().describe("alternatively, a public http(s) URL to fetch the file from"),
         fileName: external_exports.string().optional().describe("file name (used with dataUrl, or to name a fileUrl download)")
       }
     },
     async ({ groupId, path: path5, caption, dataUrl, fileUrl, fileName }, extra) => withClient(async (c2) => {
       let name, mime, url;
+      let inlineBytes = null;
       if (path5) {
         if (!ctx.local) {
-          const r = await remoteUploadCommand(c2, ctx, { groupId }, path5, caption, "the group");
+          const r = await remoteUploadCommand(c2, ctx, { groupId }, path5, caption, "the group", extra?.signal);
           return "ok" in r ? ok3(r.ok) : fail(r.fail);
         }
         const abs = resolveLocalFile(path5);
@@ -44004,10 +44168,11 @@ Or just upload ${fname} from the agent's page in the web app.`
         mime = mimeOf(name);
         url = `data:${mime};base64,${buf.toString("base64")}`;
       } else if (dataUrl && fileName) {
-        const tooBig = dataUrlTooBig(dataUrl);
-        if (tooBig) return fail(tooBig);
+        const parsed = parseInlineDataUrl(dataUrl);
+        if ("error" in parsed) return fail(parsed.error);
         name = fileName;
-        mime = dataUrl.match(/^data:([^;]+)/)?.[1] ?? mimeOf(fileName);
+        mime = parsed.mime;
+        inlineBytes = parsed.bytes;
         url = dataUrl;
       } else if (fileUrl) {
         try {
@@ -44017,10 +44182,10 @@ Or just upload ${fname} from the agent's page in the web app.`
         }
       } else {
         return fail(
-          "provide a local file `path`, a `dataUrl` + `fileName` (\u2264256KB), or a public `fileUrl`. If the file only exists INSIDE this chat (attached or generated here), the connector can't see it \u2014 ask the user to save it to their computer first, then call again with that path."
+          "provide a local file `path`, a `dataUrl` + `fileName` (\u2264256KB), or a public `fileUrl`. File in YOUR OWN sandbox (you are a cloud-sandboxed assistant)? \u2264256KB \u2192 base64 it into `dataUrl` + `fileName`; larger \u2192 call again with the file's sandbox `path` to mint a one-tap upload LINK, present the file for download, and have the user open the link and pick it. File attached in this chat that YOU can't read? Ask the user to save it to their computer, then call again with that path."
         );
       }
-      const rawBytes = Buffer.from(url.split(",")[1] ?? "", "base64");
+      const rawBytes = inlineBytes ?? Buffer.from(url.split(",")[1] ?? "", "base64");
       if (rawBytes.length > MAX_UPLOAD_BYTES)
         return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
       if (isStateless(c2)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jefrichat-mcp",
-  "version": "0.49.4",
+  "version": "0.49.6",
   "description": "Jefri Chat connector — join the Jefri Chat network (WhatsApp for AI agents) from any MCP client (Claude, Codex, Cursor, …).",
   "type": "module",
   "bin": {