toolaby 1.7.2 → 1.8.1

package/README.md

@@ -12,7 +12,7 @@ The command is `toolaby-cli`: on Windows, the Command Prompt runs a `toolaby.js`
 
 In a repository you did not write, use the installed command: `npx` can run a `toolaby` the project carries, or fetch one from a registry the project's `.npmrc` names.
 
-Every command acts on the test Wall (`test.toolaby.app`) unless told `--live` (`toolaby.app`), as Stripe's command line does. `toolaby tools` lists your ids on either side.
+Every command acts on the test Wall (`toolaby.app/test`) unless told `--live` (`toolaby.app`), as Stripe's command line does. `toolaby tools` lists your ids on either side.
 
 ## What it does
 
@@ -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

@@ -17,7 +17,7 @@
 //   toolaby whoami · logout · help
 //
 // Test and live, as Stripe's command line has them: every command acts on
-// the TEST Wall (test.toolaby.app) unless told `--live`, so the everyday
+// the TEST Wall (toolaby.app/test) unless told `--live`, so the everyday
 // command is the safe one and going live is a word you type on purpose.
 // Signed in, the command acts as you and only on your tools, as Clerk's and
 // Stripe's do: nothing is fetched for a tool your workspaces do not own. The
@@ -37,14 +37,14 @@ import { deflateRawSync } from 'node:zlib';
 import { homedir } from 'node:os';
 import { spawn } from 'node:child_process';
 import { createHmac, randomBytes } from 'node:crypto';
-import { wireManifest, drawsItself, WORKER_LINES, wallWorkerSource, configValues, wrappedBy, namedWorker as workerIn, startsPlatform as startsWall, CLASSIC_CLIENT } from './lib/manifest.js';
+import { wireManifest, sitePattern, drawsItself, WORKER_LINES, wallWorkerSource, configValues, wrappedBy, namedWorker as workerIn, startsPlatform as startsWall, CLASSIC_CLIENT } from './lib/manifest.js';
 import { wiringSummary, popupSwapIn, gatesIn, ownCode } from './lib/summary.js';
 import { detectProject, CODE_FILES, POPUP_FILES, SIDE_PANEL_FILES, filesToWrite, fillPages, scaffoldManifest, scaffoldFilesFor, surfacesOf, hasPopup, hasSidePanel, SURFACES, STALE_FILES, BUILD_COPY_NOTE, AGENT_FILES, AGENT_ENTRY_FILES } from './lib/project.js';
 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.7.2';
+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.
@@ -54,7 +54,8 @@ const positional = rest.filter((a) => !a.startsWith('--'));
 const opt = (k, d = null) => { const i = rest.indexOf(k); return i >= 0 && rest[i + 1] && !rest[i + 1].startsWith('--') ? rest[i + 1] : d; };
 // `upgrade` is `wire --force`: the platform's files replaced with the current ones, the extension's own untouched.
 const flag = (k) => rest.includes(k) || (k === '--force' && command === 'upgrade');
-const WALLS = { test: 'https://test.toolaby.app', live: 'https://toolaby.app' };
+// Test shares Live's addresses under /test, as Stripe keeps both modes on its own hosts.
+const WALLS = { test: 'https://toolaby.app/test', live: 'https://toolaby.app' };
 const live = flag('--live');
 // An address as fetch() reads it: a URL loses its tabs and line breaks when it is parsed, and kept in the name every
 // message prints, a --wall or a TOOLABY_WALL with one in it drew lines of its own (25 Sep 2026).
@@ -104,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,
@@ -533,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
@@ -621,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; }
@@ -659,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 ~. */
@@ -691,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));
@@ -700,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  ')}`);
   }
@@ -732,7 +741,7 @@ function pack() {
   // The Wall the key names must be reachable from the extension, or sign-in and the purchase handoff fail.
   for (const site of sites) {
     const hosts = manifest.host_permissions ?? []; const ec = manifest.externally_connectable?.matches ?? [];
-    if (!hosts.includes(`${site}/*`) || !ec.includes(`${site}/*`)) problems.push(`The manifest does not name ${oneLine(site)}/* in both host_permissions and externally_connectable: sign-in and the purchase would not reach the extension. \`npx -y toolaby@latest wire <tool-id> --live --force\` adds them.`);
+    if (!hosts.includes(sitePattern(site)) || !ec.includes(sitePattern(site))) problems.push(`The manifest does not name ${oneLine(sitePattern(site))} in both host_permissions and externally_connectable: sign-in and the purchase would not reach the extension. \`npx -y toolaby@latest wire <tool-id> --live --force\` adds them.`);
   }
   if (problems.length) fail(`Not packed:\n\n${problems.map((p) => `  · ${p}`).join('\n\n')}`);
 
@@ -809,9 +818,9 @@ function help() {
     webhooks endpoints                 your endpoints; add <url> registers one (secret shown once), remove <id> removes one
     login · whoami · logout            the session, per side; a command that needs one signs you in itself
 
-    Every command acts on Test (test.toolaby.app) unless told --live (toolaby.app).
+    Every command acts on Test (toolaby.app/test) unless told --live (toolaby.app).
     --wall <url> or TOOLABY_WALL names any other Wall; TOOLABY_TOKEN a session, for CI —
-    sent to Live alone, or to the one Wall TOOLABY_TOKEN_WALL names (https://test.toolaby.app for Test).
+    sent to Live alone, or to the one Wall TOOLABY_TOKEN_WALL names (https://toolaby.app/test for Test).
 
     In a repository you did not write, install it (npm i -g toolaby) and type toolaby-cli: npx can run a toolaby
     the project carries, or fetch one from a registry its .npmrc names.

package/lib/check.js

@@ -8,7 +8,7 @@ import { join, relative, resolve } from 'node:path';
 import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { oneLine, keySite, fetchBounded, readText } from './safe.js';
-import { wrappedBy, namedWorker, startsPlatform as startsWall } from './manifest.js';
+import { wrappedBy, namedWorker, startsPlatform as startsWall, sitePattern } from './manifest.js';
 import { popupSwapIn, ownCode } from './summary.js';
 
 const KEY = /tk_(test|live|dev)_[A-Za-z0-9_-]{20,}/;
@@ -118,7 +118,7 @@ export async function runCheck({ dir: given, out, api, token, detectProject, wir
     else ok('The manifest has the permissions and host permissions the Wall needs.');
     // The identity: without the `key`, each copy's id follows its folder, and once the extension is named the tool key refuses every copy not chosen.
     if (typeof manifest.key !== 'string' && /manifestKey:\s*'[A-Za-z0-9+/]{100,}={0,2}'/.test(configText)) warn(`manifest.json has no "key": each copy's id then depends on its folder, and once your extension is named the tool key refuses any copy you did not choose on the Keys page. \`npx -y toolaby@latest upgrade ${key.slug}\` adds it.`);
-  } else warn(`The manifest is generated by ${project.label}: build, then check the built manifest has ${key.site}/* in host_permissions and externally_connectable.`);
+  } else warn(`The manifest is generated by ${project.label}: build, then check the built manifest has ${sitePattern(key.site)} in host_permissions and externally_connectable.`);
 
   // 4b. The background starts the Wall: the popup and every page ask it everything, so without it nothing answers.
   const upgrade = `\`npx -y toolaby@latest upgrade ${key.slug}\``;

package/lib/manifest.js

@@ -69,6 +69,19 @@ export const loadableName = (file) => {
 };
 /** The background the manifest names, as the folder spells it: "./background.js" is background.js. */
 export const namedWorker = (manifest) => typeof manifest?.background?.service_worker === 'string' ? manifest.background.service_worker.trim().replace(/^(\.\/)+/, '') || null : null;
+/**
+ * The match pattern a manifest names the Wall by: the origin of the key's site, whatever path follows it. Test shares
+ * Live's hosts under /test (`https://northwind.toolaby.app/test`), so one pattern — `https://northwind.toolaby.app/*` —
+ * lets the same build reach either side, and a Live wiring's manifest is the one it always was.
+ */
+export function sitePattern(site) {
+    try {
+        return `${new URL(site).origin}/*`;
+    }
+    catch {
+        return `${site.replace(/\/+$/, '')}/*`;
+    }
+}
 /**
  * Whether an earlier wiring left the extension's own pages drawing the panel: a configuration that says '' for both
  * pages while the manifest names none of the Wall's. That is what `create` makes, and the "your popup first" shape
@@ -110,16 +123,17 @@ export function wireManifest(input, o) {
         did.push('the "storage" permission');
         added.push('storage');
     }
-    if (!(Array.isArray(manifest.host_permissions) && manifest.host_permissions.includes(`${o.site}/*`))) {
-        manifest.host_permissions = add(manifest.host_permissions, `${o.site}/*`);
-        did.push(`a host permission for ${o.site}`);
+    const pattern = sitePattern(o.site);
+    if (!(Array.isArray(manifest.host_permissions) && manifest.host_permissions.includes(pattern))) {
+        manifest.host_permissions = add(manifest.host_permissions, pattern);
+        did.push(`a host permission for ${host}`);
         if (!added.includes(host))
             added.push(host);
     }
     const ec = manifest.externally_connectable ?? {};
-    if (!(Array.isArray(ec.matches) && ec.matches.includes(`${o.site}/*`))) {
-        manifest.externally_connectable = { ...ec, matches: add(ec.matches, `${o.site}/*`) };
-        did.push(`externally_connectable for ${o.site}`);
+    if (!(Array.isArray(ec.matches) && ec.matches.includes(pattern))) {
+        manifest.externally_connectable = { ...ec, matches: add(ec.matches, pattern) };
+        did.push(`externally_connectable for ${host}`);
         if (!added.includes(host))
             added.push(host);
     }

package/lib/project.js

@@ -1,4 +1,21 @@
 // Generated from wall/src/packages/wiring/project.ts by wall/scripts/pack-create.mjs — edit there.
+/**
+ * What kind of extension project a folder is, and where the platform's
+ * files go in it — the same files for every kind. A plain extension has
+ * its manifest.json at the root and everything beside it. A framework
+ * (WXT, Plasmo, CRXJS) generates the manifest at build time, bundles the
+ * background, and copies a folder of files as they are: the client goes
+ * where the build can import it, the Wall's popup — and its side panel,
+ * where the extension has one — where the build copies verbatim. What the manifest and the background need is the framework's
+ * own extension point where it has one — WXT loads a module from modules/
+ * by itself, so the wiring writes one and nothing is pasted — and, where it
+ * has none (Plasmo, CRXJS), a snippet for its config: shown, never written
+ * into someone's TypeScript. Pure:
+ * given what is in the folder, it says what to write and what to say.
+ * Shared by the browser (rb/WireExtension) and the terminal
+ * (`toolaby wire`, which carries a transpiled copy).
+ */
+import { sitePattern } from './manifest.js';
 /** What to tell a developer whose build ships the extension — the Wire button, the command and the Set up page all say it in these words. */
 export const BUILD_COPY_NOTE = 'A build ships this extension: make sure it copies every toolaby* file to its output — toolaby.js, toolaby.config.js, toolaby-popup.html and the rest — the way it copies your popup.html.';
 /** Always written, where the build imports from: the platform as one file (the client and the popup UI), its config, its types. */
@@ -109,7 +126,7 @@ export function detectProject(o) {
         const worker = first(has, [`${src}background.ts`, `${src}background.js`, `${src}background/index.ts`, `${src}background/index.js`]);
         const workerFile = worker ?? `${src}background.ts`;
         const workerLines = `import { toolaby } from '${importPath(workerFile)}';\n\ntoolaby.startBackground();\n`;
-        const code = JSON.stringify({ manifest: { ...(o.manifestKey ? { key: o.manifestKey } : {}), permissions: ['storage'], host_permissions: [`${site}/*`], externally_connectable: { matches: [`${site}/*`] } } }, null, 2).replace(/^\{\n|\n\}$/g, '');
+        const code = JSON.stringify({ manifest: { ...(o.manifestKey ? { key: o.manifestKey } : {}), permissions: ['storage'], host_permissions: [sitePattern(site)], externally_connectable: { matches: [sitePattern(site)] } } }, null, 2).replace(/^\{\n|\n\}$/g, '');
         return {
             kind: 'plasmo', label: 'Plasmo', codeDir: '', popupDir: '', manifestFile: null, wrapper: false, appPopup: null, appSidePanel: null, worker, built: false, foundManifest: null,
             createWorker: worker ? null : { file: workerFile, content: workerLines },

package/lib/safe.js

@@ -60,15 +60,17 @@ export const oneLine = (value) => String(value).replace(/\s+/g, ' ').slice(0, 50
 const wallScheme = (url) => url.protocol === 'https:' || (url.protocol === 'http:' && LOOPBACK.test(url.hostname));
 
 /**
- * The Wall a tool key names, when `check` may ask it anything: an origin, https or on this machine, and nothing else —
- * no path, no credentials, no other scheme — or null. The key is read from the project's own toolaby.config.js, and a
+ * The Wall a tool key names, when `check` may ask it anything: an origin, https or on this machine, with nothing after
+ * it but Test's `/test`, where Test shares Live's hosts — no other path, no query, no credentials, no other scheme.
+ * Null otherwise. The key is read from the project's own toolaby.config.js, and a
  * cloned project's key sent `check`'s requests wherever it named: a server inside the developer's network, any path on
  * any host (25 Sep 2026).
  */
 export function keySite(site) {
   let url;
   try { url = new URL(site); } catch { return null; }
-  return url.origin === site && wallScheme(url) ? site : null;
+  const path = url.pathname === '/' ? '' : url.pathname;
+  return (path === '' || path === '/test') && `${url.origin}${path}` === site && wallScheme(url) ? site : null;
 }
 
 /**
@@ -115,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 });
   }
@@ -673,13 +693,18 @@ function publicLinkEntries(root, packed = null) {
 /**
  * The page `login` opens: the one the Wall gave, when it is the Wall's own over https — or, for a Wall on this
  * machine, a page on this machine. Anything else is null, and is not opened: an address elsewhere, a downgrade to
- * http, or a scheme such as file: that opens whatever it names.
+ * http, or a scheme such as file: that opens whatever it names. A Wall under a path gives a page under it: Test at
+ * toolaby.app/test approves its codes at toolaby.app/test/…, and Live's page of the same name knows none of them (a
+ * root path resolved against Test's own base loses /test: 29 Sep 2026).
  */
 export function signInPage(link, wall) {
   if (typeof link !== 'string') return null;
   let home; let page;
   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(/\/+$/, '');
+  // 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.7.2",
+  "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": {