toolaby 1.8.0 → 1.8.1

package/README.md

@@ -38,7 +38,7 @@ If the extension is built with WXT, CRXJS or Plasmo, the command puts the same f
 ## Where things live
 
 - Your session: `~/.config/toolaby/credentials.json`, readable by you alone (mode 600). `toolaby logout` deletes it after revoking it.
-- The session is per side. `TOOLABY_TOKEN` stands in for the file where there is no home directory (CI), and is sent to one Wall only: Live (`toolaby.app`), or the one `TOOLABY_TOKEN_WALL` names — `TOOLABY_TOKEN_WALL=https://test.toolaby.app` for a Test session. If that Wall refuses it, the session `toolaby login` stored for that Wall is used instead. `TOOLABY_WALL` or `--wall <url>` names any other Wall.
+- The session is per side. `TOOLABY_TOKEN` stands in for the file where there is no home directory (CI), and is sent to one Wall only: Live (`toolaby.app`), or the one `TOOLABY_TOKEN_WALL` names — `TOOLABY_TOKEN_WALL=https://toolaby.app/test` for a Test session. If that Wall refuses it, the session `toolaby login` stored for that Wall is used instead. `TOOLABY_WALL` or `--wall <url>` names any other Wall.
 
 `wire` and `create` write only inside the folder they work on, and never through a symbolic link. A manifest, a framework's config or a Wall that names a place outside it (`../`, an absolute path, a link) is refused before anything is written. `create` writes only the files it knows a new extension has.
 

package/bin.mjs

@@ -44,7 +44,7 @@ import { runMcp } from './lib/mcp.js';
 import { runCheck } from './lib/check.js';
 import { inside, signInPage, devicePolling, opener, privateKind, privateContent, privateCopies, googleKey, projectRoot, gitDirectory, gitObject, gitObjects, gitFile, notAnImage, unpacked, COMPRESSED, publicLinks, privateLinks, oneLine, fetchBounded, fetchHere, readBounded, readText, SCAFFOLD_FILES } from './lib/safe.js';
 
-const VERSION = '1.8.0';
+const VERSION = '1.8.1';
 const CLIENT_ID = 'toolaby-cli';
 const argv = process.argv.slice(2);
 // `--version` and `--help` are commands of their own; every other command is the first bare word.
@@ -105,9 +105,10 @@ async function api(path, { method = 'GET', body, token = storedToken() } = {}) {
   // The time ran out (fetchHere's deadline; AbortError where an older Node says so): one line, whichever part was late.
   // A Wall that answered a byte at a time held `login` and `wire` for ever (round 8, 25 Sep 2026).
   const late = (e) => (e?.name === 'TimeoutError' || e?.name === 'AbortError' ? new Error(`The Wall at ${wall} did not answer ${path.split('?')[0]} within ${ANSWER_TIME / 1000} seconds.`) : null);
-  // Only the Wall answers for the Wall: a redirect elsewhere is refused (lib/safe.js).
+  // Only the Wall answers for the Wall: a redirect elsewhere — Live's /test is Test's — is refused (lib/safe.js).
   const res = await fetchHere(`${wall}${path}`, {
     ms: ANSWER_TIME,
+    wall,
     method,
     headers: { 'Content-Type': 'application/json', Accept: 'application/json', 'User-Agent': `toolaby-cli/${VERSION}`, ...(token ? { Authorization: `Bearer ${token}` } : {}) },
     body: body ? JSON.stringify(body) : undefined,
@@ -534,6 +535,8 @@ const TOOL_KEY = /tk_(test|live|dev)_[A-Za-z0-9_-]{20,}/g;
 const LOCAL = /^(https?|wss?):\/\/(localhost|127\.0\.0\.1|\[::1\]|[^/]*\.localhost)(:\d+)?\//i;
 /** Why a file is left out as no file of the folder's own, not as a private one: never packed, --allow-private or not. */
 const NOT_OWN = ['a link', 'not a file', 'a name no zip should hold'];
+/** What pack never takes and never says it left out: a folder's dot-names, its node_modules, a zip beside the build. */
+const NEVER_PACKED = ['a name starting with a dot, never packed', 'node_modules, never packed', 'a zip, never packed'];
 
 /**
  * The files a manifest names, each with what it is to the extension, as the zip spells them: no leading ./ or /, no
@@ -622,15 +625,17 @@ function zipOf(entries) {
  * And git's other files are git's, whatever their names — its index, its refs, its logs, a config (round 9, 25 Sep 2026).
  */
 function filesIn(root, copyOf = () => null, fromLink = () => null) {
-  const found = []; const left = []; const privately = [];
+  const found = []; const left = []; const privately = []; const skipped = [];
   const allowed = flag('--allow-private');
   const judge = (name, bytes) => privateKind(name) ?? copyOf(bytes) ?? privateContent(bytes) ?? gitObject(bytes) ?? gitFile(bytes) ?? notAnImage(name, bytes);
   const judged = new Map(); // what each file found private is, by its path: a compressed one beside it is the same
   const walk = (dir) => {
     for (const name of readdirSync(dir).sort()) {
-      if (name.startsWith('.') || name === 'node_modules' || name.endsWith('.zip')) continue;
       const p = join(dir, name);
       const rel = relative(root, p).split(sep).join('/');
+      // Never packed, and not said: kept apart all the same, so a manifest that names one is still refused below — a
+      // content script under node_modules or a dot-folder made a zip Chrome did not load (29 Sep 2026).
+      if (name.startsWith('.') || name === 'node_modules' || name.endsWith('.zip')) { skipped.push([rel, NEVER_PACKED[name.startsWith('.') ? 0 : name === 'node_modules' ? 1 : 2]]); continue; }
       const st = lstatSync(p);
       if (st.isSymbolicLink()) { left.push([rel, 'a link']); continue; }
       if (/[\\\u0000-\u001f\u007f]/.test(name)) { left.push([rel, 'a name no zip should hold']); continue; }
@@ -660,7 +665,7 @@ function filesIn(root, copyOf = () => null, fromLink = () => null) {
     }
   };
   walk(root);
-  return { found, left, privately };
+  return { found, left, privately, skipped };
 }
 
 /** A path as the developer knows it: under their home folder, from ~. */
@@ -692,7 +697,7 @@ function pack() {
   if (whole.length && !allowed) fail(`Not packed: ${whole.map((l) => `${oneLine(l.link)} is ${l.why}`).join(', ')}. A build copies what a public folder links to, whole, to the top of its output.\n  Make ${whole.length > 1 ? 'each' : 'it'} a folder of its own, build again, and pack. (--allow-private packs it anyway.)`);
   if (gitDirectory(folder) && !allowed) fail(`Not packed: ${oneLine(relative(process.cwd(), folder) || '.')} is a git repository's own folder (HEAD, config and its history), as a build leaves when its public folder is a link to .git.\n  Make the public folder a folder of its own, build again, and pack. (--allow-private packs it anyway.)`);
   const fromLink = (rel) => { const hit = leaking.find((l) => l.within && (rel === l.within || rel.startsWith(`${l.within}/`))); return hit ? `from ${hit.link}, ${hit.why}` : null; };
-  const { found: files, left, privately } = filesIn(folder, copyOf, fromLink);
+  const { found: files, left, privately, skipped } = filesIn(folder, copyOf, fromLink);
   // What was left out as no file of the folder's own, and what as private.
   const links = left.filter(([, why]) => NOT_OWN.includes(why));
   const kept = left.filter((entry) => !links.includes(entry));
@@ -701,14 +706,17 @@ function pack() {
   // an icon: refused, and nothing written (round 9, 25 Sep 2026). --allow-private packs a private one; a link, never.
   const broken = [];
   for (const [path, what] of namedFiles(manifest)) {
-    const gone = left.find(([rel]) => path.toLowerCase() === rel.toLowerCase() || path.toLowerCase().startsWith(`${rel.toLowerCase()}/`));
+    const named = ([rel]) => path.toLowerCase() === rel.toLowerCase() || path.toLowerCase().startsWith(`${rel.toLowerCase()}/`);
+    const gone = left.find(named) ?? skipped.find(named);
     if (gone && !broken.some(([p]) => p === path)) broken.push([path, what, gone[1]]);
   }
   if (broken.length) {
-    const secret = broken.filter(([, , why]) => !NOT_OWN.includes(why)).length;
+    const secret = broken.filter(([, , why]) => !NOT_OWN.includes(why) && !NEVER_PACKED.includes(why)).length;
+    const never = broken.filter(([, , why]) => NEVER_PACKED.includes(why)).length;
     const advice = [
       secret && `Take out what is private and build again, or pack ${secret > 1 ? 'them' : 'it'} anyway with --allow-private, for anyone who downloads the item to read.`,
-      secret < broken.length && 'The zip holds the folder\'s own files, and never a link: make each the file itself.',
+      broken.some(([, , why]) => NOT_OWN.includes(why)) && 'The zip holds the folder\'s own files, and never a link: make each the file itself.',
+      never && `A zip never holds a dot-name, node_modules or another zip: put ${never > 1 ? 'them' : 'it'} among the extension's own files, as a bundler does.`,
     ].filter(Boolean);
     fail(`Not packed: the manifest names ${broken.length > 1 ? 'files' : 'a file'} this leaves out, and the zip would not load:\n\n${broken.map(([path, what, why]) => `  · ${oneLine(path)}, ${what} (${oneLine(why)})`).join('\n')}\n\n  ${advice.join('\n  ')}`);
   }

package/lib/safe.js

@@ -117,23 +117,41 @@ export async function readBounded(res, limit) {
   return Buffer.concat(chunks);
 }
 
+/** Where Test sits under Live's own addresses: `toolaby.app/test` (the Wall's packages/zone). */
+const TEST_PATH = '/test';
+const under = (path, base) => path === base || path.startsWith(`${base}/`);
+
+/**
+ * Whether an address is the Wall's: its origin, and for a Wall under a path, that path. Test sits under Live's origin
+ * at /test, so an origin no longer tells the two apart: a Wall with no path of its own takes nothing under /test for
+ * itself, and one under /test nothing outside it — each side's session goes to its own side alone (29 Sep 2026).
+ */
+export function withinWall(address, wall) {
+  let page; let home;
+  try { page = new URL(address); home = new URL(wall); } catch { return false; }
+  if (page.origin !== home.origin) return false;
+  const base = home.pathname.replace(/\/+$/, '');
+  return base ? under(page.pathname, base) : !under(page.pathname, TEST_PATH);
+}
+
 /**
  * A request that follows a redirect only within the address it asked — a Wall moving a page on its own host — and
  * refuses one elsewhere: fetch drops the session on the way, but the command took whatever the other address answered
- * for the Wall's word, and the MCP server handed an agent a page from any host (25 Sep 2026).
+ * for the Wall's word, and the MCP server handed an agent a page from any host (25 Sep 2026). With `wall`, only within
+ * that Wall (withinWall): the same headers go on each hop, the session among them, and Test and Live share an origin.
  *
  * And one that gives up at its time: the answer, redirects and body alike — read or not yet — within `ms` of asking, or
  * a TimeoutError, as fetchBounded's. Bounded in size alone, a Wall that answered a byte at a time held `login`, `wire`
  * and the MCP server for ever (round 8, 25 Sep 2026).
  */
-export async function fetchHere(url, { ms = 30_000, ...init } = {}) {
+export async function fetchHere(url, { ms = 30_000, wall = null, ...init } = {}) {
   const signal = AbortSignal.timeout(ms);
-  const origin = new URL(url).origin;
+  const home = wall ?? new URL(url).origin;
   let res = await fetch(url, { ...init, redirect: 'manual', signal });
   for (let hops = 0; hops < 5 && res.status >= 300 && res.status < 400 && res.headers.get('location'); hops++) {
     const next = new URL(res.headers.get('location'), url);
     await res.body?.cancel().catch(() => {});
-    if (next.origin !== origin) throw new Error(`it answered with a redirect to ${next.origin}, which is not followed`);
+    if (!withinWall(next.href, home)) throw new Error(`it answered with a redirect to ${next.origin}${next.origin === new URL(home).origin ? next.pathname : ''}, which is not followed`);
     url = next.href;
     res = await fetch(url, { ...init, redirect: 'manual', signal });
   }
@@ -685,7 +703,8 @@ export function signInPage(link, wall) {
   try { home = new URL(wall); page = new URL(link, home); } catch { return null; }
   if (page.username || page.password) return null;
   const base = home.pathname.replace(/\/+$/, '');
-  if (base && page.pathname !== base && !page.pathname.startsWith(`${base}/`)) return null;
+  // Under the Wall's own path; and for a Wall with none, nothing of Test's under /test (withinWall).
+  if (base ? !under(page.pathname, base) : under(page.pathname, TEST_PATH)) return null;
   if (page.protocol === 'https:' && page.origin === home.origin) return page.href;
   const web = page.protocol === 'http:' || page.protocol === 'https:';
   return web && LOOPBACK.test(home.hostname) && LOOPBACK.test(page.hostname) ? page.href : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolaby",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "The Toolaby command line: sign in once, then wire any Chrome extension to your tool on the Wall — sign-in, the Free plan, licences and subscriptions — or start a new one; check it, and give coding agents the Wall as an MCP server.",
   "type": "module",
   "bin": {