@tensor.chat/companion 0.2.1 → 0.3.1

package/README.md

@@ -38,7 +38,8 @@ It then appears as the folder `Devices/<name>/` in that chat's file tree.
   sandboxed — that is the point of a companion device. Git Bash is used on Windows when
   it is installed, PowerShell otherwise; `tensor-companion shell <path>` overrides it.
   A long-running command can be started as a background job and looked at later.
-- **Fetch** downloads a page or file through your connection and hands the text to the AI.
+- **Fetch** downloads a page through your connection and hands it to tensor.chat as
+  served (up to 2 MB). The AI reads it as Markdown, or as served when it asks for that.
 
 ## Approval
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tensor.chat/companion",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Lets your tensor.chat AI use this machine: files, shell and internet through your own connection.",
   "license": "MIT",
   "homepage": "https://tensor.chat",

package/src/daemon.js

@@ -169,7 +169,7 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
       case 'removepath': return await files.removepath(callRoots, a.path, { endgueltig: a.endgueltig === true });
       case 'renamepath': return files.renamepath(callRoots, a.from, a.to);
       case 'statpath': return files.statpath(callRoots, a.path);
-      case 'fetch': return fetchUrl(a.url, { signal });
+      case 'fetch': return fetchUrl(a.url, { signal, raw: a.raw === true });
       default: return { ok: false, text: `(unknown tool "${tool}" on the companion device)` };
     }
   }

package/src/tools/fetch.js

@@ -2,10 +2,36 @@
 // Fetches a URL through this machine's own internet connection and returns a text
 // view: HTML is reduced to its visible text, JSON is pretty-printed, everything else
 // is shown as text when it is text at all.
+//
+// With raw, the page goes back as served instead, for the server to convert or show
+// (Fetch modes, tensorclaw/src/deviceFetch.js). A server that does not ask for raw
+// gets the text view as before.
 
 const MAX_BYTES = 2 * 1024 * 1024;
 const MAX_CHARS = 50000;
 const TIMEOUT_MS = 20000;
+// The hub takes a message of up to 4 MB, and JSON doubles every quote and backslash
+// in a page: what goes back raw stays below this many bytes as JSON.
+const RAW_JSON_BYTES = 3 * 1024 * 1024;
+
+// The text in the charset the server named; utf-8 when it named none or one this
+// runtime does not know.
+function decode(buf, type) {
+  const m = /charset\s*=\s*"?([\w.:-]+)/i.exec(type);
+  try { return new TextDecoder(m ? m[1] : 'utf-8').decode(buf); } catch (_) { return buf.toString('utf8'); }
+}
+
+// The page goes in `page`, not `text`: the hub cuts a text at 200,000 characters.
+function rawResult(res, url, type, buf, binary, truncated) {
+  const head = { ok: res.ok, raw: true, url: res.url || url.href, httpStatus: res.status, type, bytes: buf.length, text: '' };
+  if (binary) return { ...head, binary: true, truncated };
+  let page = decode(buf, type);
+  while (Buffer.byteLength(JSON.stringify(page)) > RAW_JSON_BYTES) {
+    page = page.slice(0, Math.floor(page.length * 0.9));
+    truncated = true;
+  }
+  return { ...head, truncated, page };
+}
 
 function htmlToText(html) {
   return String(html)
@@ -21,7 +47,7 @@ function htmlToText(html) {
     .trim();
 }
 
-async function fetchUrl(rawUrl, { signal, timeoutMs } = {}) {
+async function fetchUrl(rawUrl, { signal, timeoutMs, raw = false } = {}) {
   let url;
   try { url = new URL(String(rawUrl || '').trim()); } catch (_) { return { ok: false, text: '(invalid URL)' }; }
   if (url.protocol !== 'http:' && url.protocol !== 'https:') return { ok: false, text: '(only http and https URLs can be fetched)' };
@@ -50,7 +76,9 @@ async function fetchUrl(rawUrl, { signal, timeoutMs } = {}) {
       }
     }
     const buf = Buffer.concat(chunks.map((c) => Buffer.from(c)));
-    if (buf.includes(0) && !/text|json|xml|html|javascript/.test(type)) {
+    const binary = buf.includes(0) && !/text|json|xml|html|javascript/.test(type);
+    if (raw) return rawResult(res, url, type, buf, binary, truncated);
+    if (binary) {
       return { ok: true, text: `${url.href}\nHTTP ${res.status} ${type || 'unknown type'}\n(binary content, ${size} bytes — not shown)` };
     }
     let body = buf.toString('utf8');
@@ -67,4 +95,4 @@ async function fetchUrl(rawUrl, { signal, timeoutMs } = {}) {
   }
 }
 
-module.exports = { fetchUrl, htmlToText, MAX_BYTES, MAX_CHARS };
+module.exports = { fetchUrl, htmlToText, MAX_BYTES, MAX_CHARS, RAW_JSON_BYTES };

package/src/tools/files.js

@@ -172,17 +172,26 @@ function walk(root, onEntry) {
 // A pattern written as the tree shows it ("Devices/Devbox/game/**", or just the device
 // folder "Devices/Devbox/**") narrows to that shared folder and continues relative to
 // it; anything else is matched relative to every shared folder, as before.
+// Every folder's own name is tried before the device folder: the device folder is the
+// start of every name, so tried in the same pass it caught "Devices/PC/VoiceType/*" at
+// the first folder, and only the first shared folder could be searched (03.10.2026).
 function splitTreePattern(okRoots, pattern) {
   const p = pattern.replace(/\\/g, '/');
   const low = p.toLowerCase();
+  const rest = (prefix) => {
+    if (!prefix) return null;
+    const pre = prefix.toLowerCase();
+    if (low === pre) return '*';
+    return low.startsWith(pre + '/') ? p.slice(prefix.length + 1) || '*' : null;
+  };
   for (const r of okRoots) {
-    if (!r.label) continue;
-    const parent = r.label.slice(0, r.label.lastIndexOf('/'));
-    for (const [prefix, only] of [[r.label, [r]], [parent, okRoots]]) {
-      if (!prefix) continue;
-      if (low === prefix.toLowerCase()) return { roots: only, pattern: '*' };
-      if (low.startsWith(prefix.toLowerCase() + '/')) return { roots: only, pattern: p.slice(prefix.length + 1) || '*' };
-    }
+    const after = r.label ? rest(r.label) : null;
+    if (after !== null) return { roots: [r], pattern: after };
+  }
+  for (const r of okRoots) {
+    const cut = r.label ? r.label.lastIndexOf('/') : -1;
+    const after = rest(cut > 0 ? r.label.slice(0, cut) : '');
+    if (after !== null) return { roots: okRoots, pattern: after };
   }
   return { roots: okRoots, pattern: p };
 }