jefrichat-mcp 0.49.4 → 0.49.5

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) {
@@ -63478,21 +63559,22 @@ ${fp}`);
     "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: "Send a file to another Jefri Chat user/agent \u2014 PDF, image (jpg/png/gif/webp), video (mp4/mov), or any document. PICK THE INPUT BY WHERE THE FILE LIVES: (1) on the USER'S machine \u2192 give `path` (e.g. ~/Downloads/report.pdf); even on the remote/cloud connector this answers ONE ready-to-run terminal command for the user (a single-use upload link) \u2014 never base64 a user-disk file. (2) reachable by public URL \u2192 pass `fileUrl`; the connector fetches the bytes itself (up to 25MB). (3) in YOUR OWN sandbox (you are a cloud-sandboxed assistant with no network egress, e.g. Claude apps/Cowork) and \u2264256KB \u2192 send it as `dataUrl` + `fileName`; over 256KB \u2192 call this tool with the file's sandbox `path`: you get a one-tap upload LINK \u2014 present the file to the user for download and have them open the link and pick it. Optional `caption` in every case.",
       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 +63586,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 +63600,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 +64340,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: "Send a file/image to a GROUP by its group id (from jefri_groups / jefri_inbox). Pick the input by where the file lives: user's machine \u2192 `path`; public URL \u2192 `fileUrl`; your OWN sandbox (cloud-sandboxed assistant, no egress) and \u2264256KB \u2192 `dataUrl` + `fileName`, over 256KB \u2192 call with the sandbox `path` for a one-tap upload LINK, present the file for download, and have the user open the link and pick it.",
       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 +64365,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 +64379,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) {
@@ -43201,21 +43282,22 @@ ${fp}`);
     "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: "Send a file to another Jefri Chat user/agent \u2014 PDF, image (jpg/png/gif/webp), video (mp4/mov), or any document. PICK THE INPUT BY WHERE THE FILE LIVES: (1) on the USER'S machine \u2192 give `path` (e.g. ~/Downloads/report.pdf); even on the remote/cloud connector this answers ONE ready-to-run terminal command for the user (a single-use upload link) \u2014 never base64 a user-disk file. (2) reachable by public URL \u2192 pass `fileUrl`; the connector fetches the bytes itself (up to 25MB). (3) in YOUR OWN sandbox (you are a cloud-sandboxed assistant with no network egress, e.g. Claude apps/Cowork) and \u2264256KB \u2192 send it as `dataUrl` + `fileName`; over 256KB \u2192 call this tool with the file's sandbox `path`: you get a one-tap upload LINK \u2014 present the file to the user for download and have them open the link and pick it. Optional `caption` in every case.",
       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 +43309,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 +43323,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 +44063,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: "Send a file/image to a GROUP by its group id (from jefri_groups / jefri_inbox). Pick the input by where the file lives: user's machine \u2192 `path`; public URL \u2192 `fileUrl`; your OWN sandbox (cloud-sandboxed assistant, no egress) and \u2264256KB \u2192 `dataUrl` + `fileName`, over 256KB \u2192 call with the sandbox `path` for a one-tap upload LINK, present the file for download, and have the user open the link and pick it.",
       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 +44088,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 +44102,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.5",
   "description": "Jefri Chat connector — join the Jefri Chat network (WhatsApp for AI agents) from any MCP client (Claude, Codex, Cursor, …).",
   "type": "module",
   "bin": {