toolaby 1.6.3 → 1.7.0

package/README.md

@@ -20,13 +20,16 @@ Every command acts on the test Wall (`test.toolaby.app`) unless told `--live` (`
 
 - it adds the Wall's files — a small client library, a config with your tool's id and public key, and the Wall's popup, which stands in front of yours;
 - it adds three lines to your `manifest.json` (a permission and your Wall address) and creates a background file if you have none;
+- it puts the Wall's background in front of yours, `toolaby.background.js`: yours runs as it did — a classic one's `importScripts()` included — and the Wall starts with it;
 - your own code does not change. When your popup opens, the Wall's page checks what the Free plan holds and either sends the person straight to your popup or shows sign-in, the free-use meter or the plans.
 
+It prints what it did in a few rows — `✓` done, `!` worth a look, `→` a step for you, with the exact code — and what to do next, in colour in a terminal (`NO_COLOR` turns it off). When your code sets or reads the popup itself (`chrome.action.setPopup()`, `getPopup()`), it says where; `--own-popup` keeps your popup in front.
+
 If the extension is built with WXT, CRXJS or Plasmo, the command puts the same files where that build expects them and prints the few lines to paste into the framework's config, because the framework generates the manifest itself. Nothing is installed from npm.
 
 **`toolaby create <tool-id>`** makes a new, minimal extension in a folder named after the tool, ready for *Load unpacked*.
 
-**`toolaby pack [folder]`** makes the zip for the Chrome Web Store from your built extension: the manifest's `key` left out (the store refuses one it did not issue), and refused if the build carries a Test key or points at `localhost`. A store zip is public, so files that look private (`*.pem`, `*.key`, `*.p12` and other keys, `id_rsa` and the other SSH keys, certificates, `*.env`, `credentials.json`, a service account's key such as `firebase-adminsdk-….json`, `_netrc`, source maps) are left out and named, and so is a file of any name that holds a private key or a live secret (a Stripe live key, a webhook secret, an AWS access key, a GitHub, Slack or npm token, a password in an address). A build copies what a link in `public/` points at, so `pack` also leaves out a file with the same bytes as one of the project's private files or the command's own session, a folder that is a git repository's own, and a file named as an image that holds none, and it names the links in `public/`. `--allow-private` packs what it left out. Dotfiles and links are never packed. Nothing is sent anywhere.
+**`toolaby pack [folder]`** makes the zip for the Chrome Web Store from your built extension: the manifest's `key` left out (the store refuses one it did not issue), and refused if the build carries a Test key or points at `localhost`. A store zip is public, so files that look private (`*.pem`, `*.key`, `*.p12` and other keys, `id_rsa` and the other SSH keys, certificates, `*.env`, `credentials.json`, a service account's key such as `firebase-adminsdk-….json`, `_netrc`, source maps) are left out and named, and so is a file of any name that holds a private key or a secret (a Stripe key, live or test, a webhook secret, an AWS access key, long-term or temporary, or a secret access key, an OpenAI or Anthropic key, a Google OAuth client secret, a GitHub, Slack or npm token, a PuTTY key, a Supabase `service_role` key, a password in an address), read to its end, and in UTF-16 or base64 too. A Google API key is made to be in a browser: its file is packed and named, for you to restrict the key in Google Cloud. A build copies what a link in `public/` points at, so `pack` also leaves out a file with the same bytes or text as one of the project's private files or the command's own session, in UTF-16 or base64 as well, a folder that is a git repository's own, git's history, index, refs, logs and config under any name, and a file named as an image that holds none, and it names the links in `public/`. A `.gz` or `.br` a build's compression plugin writes is judged by what it holds. It refuses a build when a file the manifest names would be left out, or when a public folder is itself a link into `.git`. `--allow-private` packs what it left out. Dotfiles and links are never packed. Nothing is sent anywhere.
 
 **`toolaby tools`** lists your tools and their ids. **`toolaby whoami`** says who you are signed in as. **`toolaby logout`** signs the command out and revokes its session on the server.
 

package/bin.mjs

@@ -32,18 +32,19 @@
 // platform's own (wall/src/packages/wiring), carried here transpiled in lib/,
 // so this and the dashboard's Wire button never disagree.
 import { mkdirSync, writeFileSync, existsSync, readFileSync, readdirSync, statSync, lstatSync, realpathSync, chmodSync, unlinkSync, renameSync } from 'node:fs';
-import { join, resolve, dirname, relative, basename, sep } from 'node:path';
+import { join, resolve, dirname, relative, basename, sep, posix } from 'node:path';
 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 } from './lib/manifest.js';
+import { wireManifest, drawsItself, WORKER_LINES, wallWorkerSource, configValues, wrappedBy, namedWorker as workerIn, startsPlatform as startsWall, CLASSIC_CLIENT } from './lib/manifest.js';
+import { wiringSummary, popupSwapIn, 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, opener, privateKind, privateContent, privateCopies, projectRoot, gitDirectory, notAnImage, publicLinks, oneLine, fetchBounded, fetchHere, readBounded, readText, SCAFFOLD_FILES } from './lib/safe.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.6.3';
+const VERSION = '1.7.0';
 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.
@@ -66,7 +67,13 @@ const side = wall === WALLS.live ? 'Live' : wall === WALLS.test ? 'Test' : wall;
 // nor any character that shows nothing — a zero width, a mark of direction, a filler — which could hide a word.
 const plain = (s) => String(s).replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f\u061c\u115f\u1160\u200b-\u200f\u2028-\u202e\u2060-\u2069\u2800\u3164\ufeff\uffa0]/g, '');
 const out = (s = '') => console.log(plain(s));
-const fail = (s) => { console.error(`\n  ${plain(s)}\n`); process.exit(1); };
+// Colour, the command's own: put on after a piece is made plain, never taken from what it prints; off when the output is
+// not a terminal, and when NO_COLOR asks (FORCE_COLOR turns it on). A line of tinted pieces goes out through `say`.
+const colour = !process.env.NO_COLOR && (process.env.FORCE_COLOR ? process.env.FORCE_COLOR !== '0' : !!process.stdout.isTTY && process.env.TERM !== 'dumb');
+const tint = (code) => (s) => (colour ? `\x1b[${code}m${plain(s)}\x1b[0m` : plain(s));
+const [green, yellow, red, cyan, bold, dim] = ['32', '33', '31', '36', '1', '2'].map(tint);
+const say = (s = '') => console.log(s);
+const fail = (s) => { console.error(`\n  ${red('✗')} ${plain(s)}\n`); process.exit(1); };
 
 // ── The session: one per Wall, in the user's config, readable by them alone ─────────────────────────────────────────
 const CONFIG_DIR = join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'toolaby');
@@ -90,14 +97,20 @@ const envElsewhere = () => (process.env.TOOLABY_TOKEN && !envRefused && !envToke
 
 /** The most of one answer the command reads from a Wall: none of the Wall's comes near it (the largest, a wiring, is under 1 MB). */
 const ANSWER_LIMIT = 4 * 1024 * 1024;
+/** How long it waits for one, the whole of it: none of the Wall's takes more than a few seconds. */
+const ANSWER_TIME = 30_000;
 
 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).
   const res = await fetchHere(`${wall}${path}`, {
+    ms: ANSWER_TIME,
     method,
     headers: { 'Content-Type': 'application/json', Accept: 'application/json', 'User-Agent': `toolaby-cli/${VERSION}`, ...(token ? { Authorization: `Bearer ${token}` } : {}) },
     body: body ? JSON.stringify(body) : undefined,
-  }).catch((e) => { throw new Error(`Could not reach ${wall}: ${e.message}`); });
+  }).catch((e) => { throw late(e) ?? new Error(`Could not reach ${wall}: ${e.message}`); });
   if (res.status === 401 && token && token === envToken()) {
     envRefused = true;
     const stored = storedToken();
@@ -105,8 +118,8 @@ async function api(path, { method = 'GET', body, token = storedToken() } = {}) {
   }
   // Read up to a few megabytes and no further: a Wall at another address (--wall, TOOLABY_WALL) that answered without
   // end filled the command's memory, and the MCP server's, which hands what it reads to an agent (25 Sep 2026).
-  // An answer cut short reads as no JSON, as it always has; only one past the limit stops the command.
-  const bytes = await readBounded(res, ANSWER_LIMIT).catch(() => Buffer.alloc(0));
+  // An answer cut short reads as no JSON, as it always has; only one past the limit, or the time, stops the command.
+  const bytes = await readBounded(res, ANSWER_LIMIT).catch((e) => { const why = late(e); if (why) throw why; return Buffer.alloc(0); });
   if (!bytes) throw new Error(`The Wall at ${wall} answered ${path.split('?')[0]} with more than ${ANSWER_LIMIT / 1024 / 1024} MB, which no answer of a Wall's is. None of it was used.`);
   let json = {};
   try { json = JSON.parse(bytes.toString('utf8')); } catch { /* not JSON: the status says what happened */ }
@@ -124,19 +137,22 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 async function login() {
   const start = await api('/api/dev-auth/device/code', { method: 'POST', body: { client_id: CLIENT_ID }, token: null });
   if (!start.ok || !start.json.device_code) fail(`The Wall at ${wall} did not start a sign-in (HTTP ${start.status}). Is the address right? --wall names another.`);
-  const { device_code, user_code, verification_uri, verification_uri_complete, interval = 5, expires_in = 600 } = start.json;
+  const { device_code, user_code, verification_uri, verification_uri_complete } = start.json;
   const link = verification_uri_complete || `${verification_uri}?user_code=${encodeURIComponent(user_code)}`;
   // The Wall's own page, over https (http on this machine), or nothing opened and nothing signed in: an address the
   // Wall hands over is opened on this computer, and a file: or another site's page opens whatever it names.
   const page = signInPage(link, wall);
   if (!page) fail(`The Wall at ${wall} gave ${JSON.stringify(String(link).slice(0, 200))} as its sign-in page, which is not its own address over https.\n  It was not opened, and nothing was signed in.`);
-  out(`\n  Sign in to the ${side} Wall to continue.\n\n    Open   ${page}\n    Code   ${oneLine(user_code)}   (approve it there — it expires in ${Math.round(expires_in / 60)} minutes)\n`);
+  // How often it asks and for how long: what the Wall said, a quarter of an hour at most (lib/safe.js).
+  const { every: first, lasts } = devicePolling(start.json);
+  out(`\n  Sign in to the ${side} Wall to continue.\n\n    Open   ${page}\n    Code   ${oneLine(user_code)}   (approve it there — it expires in ${Math.round(lasts / 60_000)} minutes)\n`);
   openBrowser(page);
-  let every = Math.max(1, Number(interval) || 5) * 1000;
-  const until = Date.now() + Number(expires_in) * 1000;
+  let every = first;
+  const until = Date.now() + lasts;
   process.stdout.write('  Waiting for your approval');
   while (Date.now() < until) {
-    await sleep(every);
+    // Never past the code's end: the last ask comes as it ends.
+    await sleep(Math.min(every, until - Date.now()));
     process.stdout.write('.');
     const poll = await api('/api/dev-auth/device/token', { method: 'POST', body: { grant_type: 'urn:ietf:params:oauth:grant-type:device_code', device_code, client_id: CLIENT_ID }, token: null });
     if (poll.ok && poll.json.access_token) {
@@ -215,7 +231,7 @@ const readJson = (path) => { try { return JSON.parse(readText(path)); } catch {
 /** A project file's text, or `none` where it is no file to read (lib/safe.js readText): a link to a device reads as nothing. */
 const readOr = (path, none = null) => { try { return readText(path); } catch { return none; } };
 /** Whether a background already starts the platform, outside its comments: then it needs no lines added. */
-const startsPlatform = (path) => { try { return /\bstartBackground\s*\(/.test(readText(path).replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, '')); } catch { return false; } };
+const startsPlatform = (path) => { try { return startsWall(readText(path)); } catch { return false; } };
 const isId = (s) => typeof s === 'string' && /^[a-z0-9][a-z0-9-]{1,118}$/.test(s);
 /** Whether anything is at the path, a link to nowhere included (existsSync follows a link, and says no for a dangling one). */
 const there = (path) => { try { lstatSync(path); return true; } catch { return false; } };
@@ -281,9 +297,13 @@ async function wire() {
   const oldConfig = existsSync(configPath) ? readOr(configPath, '') : '';
   const remembered = oldConfig.match(/appPopup:\s*'([^']*)'/)?.[1] || null;
   const rememberedSidePanel = oldConfig.match(/appSidePanel:\s*'([^']*)'/)?.[1] || null;
-  // An extension whose own pages draw the panel — what `create` makes, or "your popup first" — keeps them in front.
-  const ownInFront = drawsItself(manifest, oldConfig);
-  const wiring = project.manifestFile && manifest ? wireManifest(manifest, { site, has, remembered, rememberedSidePanel, manifestKey, ownInFront }) : null;
+  // An extension whose own pages draw the panel — what `create` makes, "your popup first", or asked with --own-popup —
+  // keeps them in front.
+  const ownInFront = flag('--own-popup') || drawsItself(manifest, oldConfig);
+  // The background the manifest names, read from inside the folder only: whether it starts the Wall, or is the Wall's.
+  const namedWorker = workerIn(manifest) ?? '';
+  const workerSource = namedWorker && has(namedWorker) && !inside(dir, namedWorker).why ? readOr(join(dir, namedWorker), '') : null;
+  const wiring = project.manifestFile && manifest ? wireManifest(manifest, { site, has, remembered, rememberedSidePanel, manifestKey, ownInFront, workerSource }) : null;
   const appPopup = wiring ? wiring.appPopup : project.wrapper ? (project.appPopup ?? remembered) : null;
   const appSidePanel = wiring ? wiring.appSidePanel : project.wrapper ? (project.appSidePanel ?? rememberedSidePanel) : null;
   const targets = filesToWrite(project, appPopup, appSidePanel, { popup: !!wiring?.ownPopup, sidePanel: !!wiring?.ownSidePanel });
@@ -292,8 +312,13 @@ async function wire() {
   // What an earlier wiring wrote and this one does not, wherever it put them: taken away, so nothing stale is shipped.
   const stale = [...new Set([project.codeDir, project.popupDir, 'public/', 'src/public/'])].flatMap((under) => STALE_FILES.map((f) => `${under}${f}`)).filter((p) => existsSync(join(dir, p)));
   // The background a manifest names and that is not there is written — at the name the manifest gives, which is the repository's to choose.
-  const worker = wiring ? wiring.writeWorker : project.createWorker?.file ?? null;
-  const at = placesIn(dir, [...targets, ...entries, ...stale, ...(worker ? [worker] : []), ...(wiring?.did.length ? ['manifest.json'] : [])], worker ? { [worker]: 'the background the manifest names' } : {});
+  const worker = wiring ? (wiring.background.kind === 'new' ? wiring.background.file : null) : project.createWorker?.file ?? null;
+  // The extension's own background, with the Wall's in front of it — and, for a classic one, the client as a script.
+  const wrap = wiring?.background.kind === 'wrap' ? wiring.background : null;
+  const classicClient = wrap?.classic ? `${project.codeDir}${CLASSIC_CLIENT}` : null;
+  const at = placesIn(dir, [...targets, ...entries, ...stale, ...(worker ? [worker] : []), ...(wrap ? [wrap.file] : []), ...(classicClient ? [classicClient] : []), ...(wiring?.changed ? ['manifest.json'] : [])], { ...(worker ? { [worker]: 'the background the manifest names' } : {}), ...(wrap ? { [wrap.file]: "the Wall's background, beside yours" } : {}) });
+  // A file of the developer's own where the Wall's background goes is never replaced: only one the Wall wrote.
+  if (wrap && wrap.file !== namedWorker && there(at[wrap.file]) && !wrappedBy(readOr(at[wrap.file], ''))) fail(`${wrap.file} is already in ${dir}, and it is not the Wall's. Rename it, then run this again. Nothing was written.`);
   // Taken for missing, it may only be out of the listing's sight — spelt "./background.js", in dist/, or deeper down:
   // the developer's own background is never replaced by two lines of ours.
   if (worker && there(at[worker])) fail(`${JSON.stringify(worker)}, the background the manifest names, is already in ${dir}; it would have been replaced. Nothing was written.\n  Name it in the manifest as the folder spells it — or, if a build writes it, run this with --into the folder whose manifest.json names it.`);
@@ -303,41 +328,40 @@ async function wire() {
   // A command older than the Wall asks for files the Wall no longer hands out: said, with the way to the current one, rather than a crash.
   // The agent files come from Walls that write them; one that does not is older, not newer, than this command.
   const agentPaths = new Set(AGENT_FILES.map((f) => f.path));
-  const missing = targets.filter((p) => !agentPaths.has(p)).map((p) => p.split('/').pop()).filter((name) => typeof plan.files[name] !== 'string');
+  const missing = [...targets, ...(classicClient ? [classicClient] : [])].filter((p) => !agentPaths.has(p)).map((p) => p.split('/').pop()).filter((name) => typeof plan.files[name] !== 'string');
   if (missing.length) fail(`This command (${VERSION}) is older than the Wall at ${wall}: it expects ${missing.join(', ')}, which the Wall no longer hands out.\n  Update it: npm install -g toolaby@latest — or run the Wall's own copy: npx --yes ${wall}/toolaby.tgz ${command} ${slug}`);
   const wrote = targets.filter((path) => typeof plan.files[path.split('/').pop()] === 'string');
   for (const path of wrote) write(path, fillPages(plan.files[path.split('/').pop()], { appPopup, appSidePanel }));
   for (const f of entries) { write(f, plan.files[f]); wrote.push(f); }
   const ownAgents = has('AGENTS.md') && !readOr(join(dir, 'AGENTS.md'), '').includes('TOOLABY.md');
   for (const p of stale) unlinkSync(at[p]);
-  const did = [];
-  let ownWorker = null;
   if (wiring) {
-    if (wiring.writeWorker) write(wiring.writeWorker, WORKER_LINES);
-    if (wiring.did.length) write('manifest.json', JSON.stringify(wiring.manifest, null, 2) + '\n');
-    did.push(...wiring.did);
-    if (wiring.ownWorker && !startsPlatform(join(dir, wiring.ownWorker.file))) ownWorker = wiring.ownWorker;
+    if (wiring.background.kind === 'new') write(wiring.background.file, WORKER_LINES);
+    // The Wall's background in front of theirs, with what toolaby.config.js starts the Wall with (a classic one carries it).
+    if (wrap) write(wrap.file, wallWorkerSource(wrap, wrap.classic ? configValues(fillPages(plan.files['toolaby.config.js'], { appPopup, appSidePanel })) : null));
+    if (classicClient) write(classicClient, plan.files[CLASSIC_CLIENT]);
+    if (wiring.changed) write('manifest.json', JSON.stringify(wiring.manifest, null, 2) + '\n');
   } else if (project.createWorker) {
     write(project.createWorker.file, project.createWorker.content);
-    did.push(`a background entry, ${project.createWorker.file} (it starts the platform)`);
-  } else if (project.worker && !project.extraFiles && !startsPlatform(join(dir, project.worker))) {
-    // A framework with its own extension point (WXT's module) starts the platform in the background itself.
-    ownWorker = { file: project.worker, classic: false };
   }
-
-  out(`\n  ${oneLine(plan.name)} → ${dir}${project.kind === 'plain' ? '' : `  (${project.label})`}  ·  ${side}${side === 'Test' ? ' (the tk_test_ key; `--live` for the store build)' : ''}\n`);
-  // Each thing done is a line, and names what the manifest and the Wall named: the popup, the background, the address.
-  out(`  Written: ${wrote.join(', ')}${did.length ? `,\n           ${did.map(oneLine).join(',\n           ')}` : ''}.\n`);
-  if (ownAgents) out('  Your AGENTS.md is your own: add a line so coding agents find the Wall\'s guide — "Before changing anything paid, read TOOLABY.md."\n');
-  if (stale.length) out(`  Removed: ${stale.join(', ')} — earlier files, now inside toolaby.js.\n`);
-  for (const sn of project.snippets) out(`  Add to ${sn.file} — yours to paste, the manifest being generated:\n\n${sn.code.split('\n').map((l) => `     ${l}`).join('\n')}\n`);
-  if (ownWorker) out(`  Your background, ${oneLine(ownWorker.file)}: add${ownWorker.classic ? ' — after giving "background" a "type": "module" in manifest.json (importScripts() is not available in a module worker)' : ''}:\n\n${project.workerLines.trimEnd().split('\n').map((l) => `     ${l}`).join('\n')}\n`);
-  if (project.built) out(`  ${BUILD_COPY_NOTE}\n`);
-  out(`  Next: ${project.kind === 'plain' && !project.built ? '' : 'build or start the dev server, then '}chrome://extensions → reload it. The tool's Set up page says "checked in" the moment it starts.`);
-  if (project.note) out(`  ${project.note}\n`);
-  else if (appPopup || appSidePanel) out(`  Your ${appPopup && appSidePanel ? 'popup and side panel open' : appSidePanel ? 'side panel opens' : 'popup opens'} as before; what the Free plan holds (Pricing, in the dashboard) decides when the Wall's panel takes its place.\n`);
-  else if (ownInFront && (wiring?.ownPopup || wiring?.ownSidePanel)) out(`  Your ${wiring.ownPopup && wiring.ownSidePanel ? 'popup and side panel stay' : wiring.ownSidePanel ? 'side panel stays' : 'popup stays'} in front and draw${wiring.ownPopup && wiring.ownSidePanel ? '' : 's'} the panel, as before; toolaby.showPaywall() opens the Wall's page beside it.\n`);
-  else out(`  No popup or side panel to stand in front of: count a use where your feature runs — the Set up page shows the line.\n`);
+  // The extension's own code, read for a popup it swaps while it runs: the Wall's in front of it could be skipped then.
+  const code = appPopup ? [...tree].filter(ownCode).slice(0, 400).map((path) => { let text = ''; try { if (statSync(join(dir, path)).size < 512_000) text = readOr(join(dir, path), ''); } catch { /* gone */ } return { path, text }; }) : [];
+  const summary = wiringSummary({ project, wiring, appPopup, appSidePanel, workerStarts: !!project.worker && startsPlatform(join(dir, project.worker)), popupSwap: popupSwapIn(code) });
+
+  // Wired again, a folder takes `upgrade` (wire, replacing the platform's files): the command, ready to paste.
+  const into = opt('--into');
+  const again = `npx -y toolaby@latest upgrade ${slug}${live ? ' --live' : ''}${into ? ` --into ${/^[\w@%+=:,./-]+$/.test(into) ? into : `'${into.replace(/'/g, "'\\''")}'`}` : ''}`;
+  say(`\n  ${summary.todo ? `${yellow('!')} ${bold('Almost wired')}` : `${green('✓')} ${bold('Wired')}`}  ${plain(oneLine(plan.name))} → ${plain(basename(dir))}  ${dim(`· ${side}${project.kind === 'plain' ? '' : ` · ${project.label}`}`)}\n`);
+  const width = Math.max(...summary.rows.map((r) => r.label.length));
+  for (const r of summary.rows) {
+    const mark = r.tone === 'ok' ? green('✓') : r.tone === 'warn' ? yellow('!') : cyan('→');
+    say(`    ${mark} ${bold(r.label.padEnd(width))}  ${plain(oneLine(r.text))}`);
+    if (r.fix === 'own-popup') say(`      ${' '.repeat(width)}  ${cyan(`${again} --own-popup`)}`);
+    if (r.code) say(`\n${r.code.split('\n').map((l) => `        ${cyan(l)}`).join('\n')}\n`);
+  }
+  if (ownAgents) say(`    ${dim('Your AGENTS.md is your own: add "Before changing anything paid, read TOOLABY.md."')}`);
+  if (stale.length) say(`    ${dim(`Removed: ${stale.join(', ')} (now inside toolaby.js)`)}`);
+  say(`\n  ${bold('Next')}  ${summary.rows.some((r) => r.again) ? `${plain(summary.next.replace(/wire again\.$/, 'run'))} ${cyan(again)}` : plain(summary.next)}\n`);
 }
 
 async function create() {
@@ -496,10 +520,52 @@ async function webhooks() {
 // admits that id once the listing's address is on the tool. It refuses a build that would sell on Test (a tk_test_
 // or tk_dev_ key inside) or that points at this machine (localhost in the manifest), the two mistakes a store build
 // can ship with. What looks private — a key, an environment file, a source map — is left out and named, and so is a
-// link out of the folder: a store zip is public. Nothing is sent anywhere: it reads the folder and writes one file.
+// link out of the folder: a store zip is public. A build it would leave a file of the manifest's out of, which Chrome
+// would not load, is refused, as is one whose public folder is a link into .git (round 9, 25 Sep 2026). Nothing is
+// sent anywhere: it reads the folder and writes one file.
 const BUILD_DIRS = ['.', '.output/chrome-mv3', 'dist', 'build/chrome-mv3-prod', 'build'];
 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'];
+
+/**
+ * The files a manifest names, each with what it is to the extension, as the zip spells them: no leading ./ or /, no
+ * query or fragment. A pattern (a web-accessible resource's `*`) names no one file, and an address none at all.
+ */
+function namedFiles(manifest) {
+  const named = [];
+  const add = (path, what) => {
+    if (typeof path !== 'string' || path.includes('*') || /^[a-z][a-z0-9+.-]*:/i.test(path)) return;
+    const clean = posix.normalize(path.split(/[?#]/)[0].replace(/^(?:\.?\/)+/, ''));
+    if (clean && clean !== '.' && clean !== '..' && !clean.startsWith('../')) named.push([clean, what]);
+  };
+  const list = (value) => (Array.isArray(value) ? value : []);
+  const icons = (value) => { for (const path of value && typeof value === 'object' ? Object.values(value) : [value]) add(path, 'an icon'); };
+  add('manifest.json', 'the manifest');
+  add(manifest.background?.service_worker, 'the background service worker');
+  for (const path of list(manifest.background?.scripts)) add(path, 'a background script');
+  add(manifest.background?.page, 'the background page');
+  for (const script of list(manifest.content_scripts)) {
+    for (const path of list(script?.js)) add(path, 'a content script');
+    for (const path of list(script?.css)) add(path, "a content script's style sheet");
+  }
+  for (const surface of ['action', 'browser_action', 'page_action']) { add(manifest[surface]?.default_popup, 'the popup'); icons(manifest[surface]?.default_icon); }
+  add(manifest.side_panel?.default_path, 'the side panel');
+  add(manifest.sidebar_action?.default_panel, 'the side panel');
+  icons(manifest.sidebar_action?.default_icon);
+  add(manifest.options_page, 'the options page');
+  add(manifest.options_ui?.page, 'the options page');
+  add(manifest.devtools_page, 'the DevTools page');
+  if (manifest.chrome_url_overrides && typeof manifest.chrome_url_overrides === 'object') for (const path of Object.values(manifest.chrome_url_overrides)) add(path, 'a page it replaces');
+  for (const path of list(manifest.sandbox?.pages)) add(path, 'a sandboxed page');
+  icons(manifest.icons);
+  for (const entry of list(manifest.web_accessible_resources)) for (const path of typeof entry === 'string' ? [entry] : list(entry?.resources)) add(path, 'a web-accessible resource');
+  for (const rules of list(manifest.declarative_net_request?.rule_resources)) add(rules?.path, 'a rule set');
+  add(manifest.storage?.managed_schema, 'its managed storage schema');
+  if (typeof manifest.default_locale === 'string') add(`_locales/${manifest.default_locale}/messages.json`, 'its default locale');
+  return named;
+}
 
 const CRC_TABLE = Array.from({ length: 256 }, (_, n) => { let c = n; for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1; return c >>> 0; });
 const crc32 = (buf) => { let c = 0xffffffff; for (const b of buf) c = CRC_TABLE[(c ^ b) & 0xff] ^ (c >>> 8); return (c ^ 0xffffffff) >>> 0; };
@@ -542,10 +608,18 @@ function zipOf(entries) {
  * A build has already followed the links of the project it came from: what they pointed at is an ordinary file here.
  * So a file is also private when it is a copy of one of the project's (`copyOf`), a folder when it is a git
  * repository's own, and a file named as an image when it holds none (round 7, 25 Sep 2026).
+ *
+ * And a compressed file is what it holds (round 8, 25 Sep 2026): a build's compression plugin writes data.json.gz and
+ * data.json.br beside data.json, and `pack` left data.json out as private while it packed both. One beside a file left
+ * out goes with it, however large; any other is opened, a few MB of it at most (lib/safe.js), and judged as the file.
+ *
+ * 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) {
+function filesIn(root, copyOf = () => null, fromLink = () => null) {
   const found = []; const left = []; const privately = [];
   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;
@@ -554,15 +628,27 @@ function filesIn(root, copyOf = () => null) {
       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; }
+      // What a build copied from a link into .git, or to a private file, left out whole, as the link's (round 8).
+      const via = fromLink(rel);
+      if (via) { judged.set(rel, via); if (!allowed) { left.push([rel, via]); continue; } privately.push([rel, via]); }
       if (st.isDirectory()) {
         // Left out whole, unwalked: its config and its history are the repository's, whatever the folder is called.
-        if (gitDirectory(p)) { if (!allowed) { left.push([rel, 'a git directory']); continue; } privately.push([rel, 'a git directory']); }
+        const git = gitDirectory(p) ? 'a git directory' : gitObjects(p) ? 'git history' : null;
+        if (git && !via) { if (!allowed) { left.push([rel, git]); continue; } privately.push([rel, git]); }
         walk(p);
         continue;
       }
       if (!st.isFile()) { left.push([rel, 'not a file']); continue; }
       const bytes = readFileSync(p);
-      const why = privateKind(name) ?? copyOf(bytes) ?? privateContent(bytes) ?? notAnImage(name, bytes);
+      let why = judge(name, bytes);
+      if (!why) {
+        // Sorted, data.json comes before data.json.br and data.json.gz: its verdict is known when theirs is asked.
+        const twin = COMPRESSED.test(name) ? judged.get(rel.replace(COMPRESSED, '')) : null;
+        const inner = twin ? null : unpacked(name, bytes);
+        const held = twin ?? (inner && judge(inner.name, inner.bytes));
+        if (held) why = `${held}, compressed`;
+      }
+      if (why) judged.set(rel, why);
       if (why && !allowed) left.push([rel, why]);
       else { found.push(p); if (why) privately.push([rel, why]); }
     }
@@ -588,8 +674,38 @@ function pack() {
   // The project the build came from — or, with none above it, the folder alone — and the command's own secrets: what a
   // build could have copied in under another name, by following a link (lib/safe.js).
   const project = projectRoot(folder);
+  const allowed = flag('--allow-private');
   const copyOf = privateCopies(project ?? folder, [[CREDENTIALS, `${fromHome(CREDENTIALS)}, this command's session`], [DEV_SECRET_FILE, `${fromHome(DEV_SECRET_FILE)}, this machine's webhook secret`]]);
-  const { found: files, left, privately } = filesIn(folder, copyOf);
+  // What a link in the project's public folders put into the build, when it points into .git or at a private file.
+  const leaking = project ? privateLinks(project, folder) : [];
+  // A public folder that is itself such a link, or a build whose top is a git repository's own folder, is refused: the
+  // build copied what the link points at to the top of its output, among the extension's own files, and nothing tells
+  // them apart — `public -> .git` put the repository's index, its logs and its last commit message in the zip (round 9,
+  // 25 Sep 2026).
+  const whole = leaking.filter((l) => !l.within);
+  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);
+  // 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));
+
+  // A file the manifest names that is left out makes a zip Chrome does not load, or loads without its worker, a page or
+  // 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()}/`));
+    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 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.',
+    ].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  ')}`);
+  }
   const problems = [];
 
   // Which side the build sells on: the tool keys inside it, wherever the bundler put them.
@@ -632,12 +748,14 @@ function pack() {
   renameSync(fresh, target);
   const kb = (statSync(target).size / 1024).toFixed(0);
   out(`\n  ${relative(process.cwd(), target) || target}  ·  ${entries.length} files, ${kb} KB  ·  version ${manifest.version}${modes.has('live') ? '  ·  Live key' : ''}`);
-  // What was left out, and why — or, asked for, what private file went in: a store zip is public.
-  const links = left.filter(([, why]) => why === 'a link' || why === 'not a file' || why === 'a name no zip should hold');
-  const kept = left.filter((entry) => !links.includes(entry));
-  if (kept.length) out(`  Left out, as private: ${kept.map(([f, why]) => `${oneLine(f)} (${why})`).join(', ')}. Anyone can download a store item and unzip it; --allow-private packs ${kept.length > 1 ? 'them' : 'it'} anyway.`);
+  // What was left out, and why — or, asked for, what private file went in: a store zip is public. A reason can name a
+  // file of the project's (a copy of…, from a link…), and so is put on one line, as the file's own name is.
+  if (kept.length) out(`  Left out, as private: ${kept.map(([f, why]) => `${oneLine(f)} (${oneLine(why)})`).join(', ')}. Anyone can download a store item and unzip it; --allow-private packs ${kept.length > 1 ? 'them' : 'it'} anyway.`);
   if (links.length) out(`  Left out: ${links.map(([f, why]) => `${oneLine(f)} (${why})`).join(', ')}. The zip holds the folder's own files: copy in what belongs in it.`);
-  if (privately.length) out(`  Packed as asked (--allow-private): ${privately.map(([f, why]) => `${oneLine(f)} (${why})`).join(', ')}. Anyone who downloads the item can read ${privately.length > 1 ? 'them' : 'it'}.`);
+  if (privately.length) out(`  Packed as asked (--allow-private): ${privately.map(([f, why]) => `${oneLine(f)} (${oneLine(why)})`).join(', ')}. Anyone who downloads the item can read ${privately.length > 1 ? 'them' : 'it'}.`);
+  // Packed and named: a Google API key is made to be in a browser, and kept to its use by its restrictions (lib/safe.js).
+  const google = entries.filter(([, bytes]) => googleKey(bytes)).map(([name]) => oneLine(name));
+  if (google.length) out(`  ${google.length > 1 ? 'Google API keys are' : 'A Google API key is'} in ${google.join(', ')}: anyone who downloads the item can read ${google.length > 1 ? 'them' : 'it'}. Restrict ${google.length > 1 ? 'each' : 'it'} to this extension, and to the APIs it calls, in Google Cloud → Credentials.`);
   // Said, not refused: the links are the project's, not the build's, and the build may hold nothing of theirs yet.
   const linked = project ? publicLinks(project, folder) : [];
   if (linked.length) out(`  Links in the folders a build copies as they are: ${linked.slice(0, 8).map(oneLine).join(', ')}${linked.length > 8 ? ` and ${linked.length - 8} more` : ''}. The build copies what each points at, a private file too: make each the file itself.`);
@@ -653,7 +771,7 @@ function mcp() {
 }
 
 async function check() {
-  const passed = await runCheck({ dir: opt('--into') ?? positional[0] ?? '.', out, api: (path, o = {}) => api(path, o), token: storedToken, detectProject, wireManifest, listTree, readJson, browser: flag('--browser') });
+  const passed = await runCheck({ mark: (tone, text) => say(`  ${tone === 'ok' ? green('✓') : tone === 'warn' ? yellow('!') : red('✗')} ${plain(text)}`), dir: opt('--into') ?? positional[0] ?? '.', out, api: (path, o = {}) => api(path, o), token: storedToken, detectProject, wireManifest, listTree, readJson, browser: flag('--browser') });
   if (!passed) process.exit(1);
 }
 
@@ -664,14 +782,17 @@ function help() {
     toolaby wire <tool-id>             wire the extension in this folder to your tool, on Test
     toolaby wire <tool-id> --live      the same, on Live: the store build
                                        --into <folder>   another folder     --force   replace the platform's files
+                                       --own-popup       keep your popup in front (the Wall's opens from toolaby.showPaywall())
     toolaby upgrade <tool-id>          the platform's files replaced with the current ones — the popup, the client — yours untouched
     toolaby create <tool-id>           a new, minimal extension for your tool, in <tool-id>/   --dir <folder>
                                        --surfaces both|popup|side-panel|none   what it opens (default: both)
     toolaby tools                      your tools, with their ids
     toolaby pack [folder]              the zip for the Chrome Web Store: the built extension, its manifest's "key" left out;
                                        refuses a Test key or localhost inside   --out <file.zip>
-                                       leaves out keys, certificates, .env and credential files, source maps, live secrets,
-                                       a build's copy of a private file, a git folder, an image that is none   --allow-private packs them
+                                       leaves out keys, certificates, .env and credential files, source maps, secrets,
+                                       git's files, a build's copy of a private file (compressed, UTF-16 or base64),
+                                       an image that is none; refuses a build if one is a file the manifest names
+                                       --allow-private packs them
     toolaby check [folder]             whether the extension here is wired right: files, key, manifest, client, features;
                                        --browser loads it in Chromium (needs Playwright in the project)
     toolaby mcp                        the Wall for coding agents, an MCP server on stdio:

package/lib/check.js

@@ -8,6 +8,8 @@ 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 { popupSwapIn, ownCode } from './summary.js';
 
 const KEY = /tk_(test|live|dev)_[A-Za-z0-9_-]{20,}/;
 /** A tool id as the Wall makes them (lib/mcp.js has the same): the only thing the check puts after a Wall's address. */
@@ -53,12 +55,14 @@ export function featuresUsed(source) {
   return keys;
 }
 
-export async function runCheck({ dir: given, out, api, token, detectProject, wireManifest, listTree, readJson, browser }) {
+export async function runCheck({ dir: given, out, api, token, detectProject, wireManifest, listTree, readJson, browser, mark = null }) {
   const dir = resolve(given ?? '.');
   const results = [];
-  const ok = (s) => { results.push('ok'); out(`  ✓ ${s}`); };
-  const warn = (s) => { results.push('warn'); out(`  ! ${s}`); };
-  const bad = (s) => { results.push('bad'); out(`  ✗ ${s}`); };
+  // `mark` prints a line with the command's own coloured mark (bin.mjs); without it, the plain one.
+  const line = (tone, sign, s) => { results.push(tone); if (mark) mark(tone, s); else out(`  ${sign} ${s}`); };
+  const ok = (s) => line('ok', '✓', s);
+  const warn = (s) => line('warn', '!', s);
+  const bad = (s) => line('bad', '✗', s);
   out(`\n  Checking ${dir}\n`);
 
   // 1. What the folder is.
@@ -105,14 +109,46 @@ export async function runCheck({ dir: given, out, api, token, detectProject, wir
 
   // 4. The manifest, against the platform's own wiring rules: what wiring it again would add.
   if (project.manifestFile && manifest) {
-    const again = wireManifest(manifest, { site: key.site, has, remembered: null, rememberedSidePanel: null, manifestKey: typeof manifest.key === 'string' ? manifest.key : null });
-    const needed = (again.did ?? []).filter((d) => !/popup|side panel/i.test(d));
+    const named = namedWorker(manifest) ?? '';
+    const workerText = named && has(named) ? readOr(join(dir, named), null) : null;
+    const again = wireManifest(manifest, { site: key.site, has, remembered: null, rememberedSidePanel: null, manifestKey: typeof manifest.key === 'string' ? manifest.key : null, workerSource: workerText });
+    // The background is said below, in a line of its own.
+    const needed = (again.did ?? []).filter((d) => !/popup|side panel|service worker/i.test(d));
     if (needed.length) bad(`The manifest lacks what the Wall needs: ${needed.map(oneLine).join('; ')}. \`npx -y toolaby@latest upgrade ${key.slug}\` adds it.`);
     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.`);
 
+  // 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}\``;
+  if (project.manifestFile && manifest) {
+    const named = namedWorker(manifest) ?? '';
+    const text = named && has(named) ? readOr(join(dir, named), null) : null;
+    const wraps = wrappedBy(text);
+    // What wiring again would do with it, by the same rules (wiring/manifest).
+    const b = wireManifest(manifest, { site: key.site, has, workerSource: text }).background;
+    if (!named || text === null) bad(`Nothing starts the Wall: the manifest names no background${named ? ` it can find (${oneLine(named)})` : ''}. ${upgrade} adds one.`);
+    else if (b.kind === 'gone') bad(`${oneLine(named)} runs ${oneLine(b.wraps)}, which is no longer in the folder. Put your background's file name in manifest.json, then ${upgrade}.`);
+    else if (b.kind === 'rename') bad(`The Wall can't load a file named ${JSON.stringify(oneLine(b.file))}. Rename it to ${oneLine(b.to)}, put that in manifest.json, then ${upgrade}.`);
+    else if (b.kind === 'lines') bad(`${oneLine(b.file)} never starts the Wall, so the popup cannot reach it. Add at its top: ${oneLine(project.workerLines.trim().replace(/\n+/g, ' '))}`);
+    else if (wraps) {
+      // A classic one carries the key it starts with: the one in toolaby.config.js, or the background starts with an old one.
+      const carried = text.match(/"key":"([^"]+)"/)?.[1];
+      if (carried && carried !== keyText) bad(`${oneLine(named)} starts the Wall with another key than toolaby.config.js. \`npx -y toolaby@latest upgrade ${key.slug}\` writes both again.`);
+      else ok(`The background starts the Wall, and runs yours (${oneLine(wraps)}).`);
+    } else if (startsWall(text)) ok(`The background (${oneLine(named)}) starts the Wall.`);
+    else bad(`${oneLine(named)} never starts the Wall, so the popup cannot reach it. ${upgrade} puts the Wall's in front of it; yours stays as it is.`);
+  } else if (project.worker && !project.extraFiles) {
+    if (startsWall(readOr(join(dir, project.worker), ''))) ok(`The background (${oneLine(project.worker)}) starts the Wall.`);
+    else bad(`${oneLine(project.worker)} never starts the Wall, so the popup cannot reach it. Add at its top: ${oneLine(project.workerLines.trim().replace(/\n+/g, ' '))}`);
+  }
+  // A popup the code swaps while it runs: the Wall's in front of it can be skipped.
+  if (project.manifestFile && manifest?.action?.default_popup === 'toolaby-popup.html') {
+    const swap = popupSwapIn(sourceFiles(dir).map((f) => relative(dir, f).split('\\').join('/')).filter(ownCode).map((path) => ({ path, text: readOr(join(dir, path), '') })));
+    if (swap) warn(`Your code handles the popup itself (${oneLine(swap.call)} in ${oneLine(swap.file)}): \`npx -y toolaby@latest upgrade ${key.slug} --own-popup\` keeps yours in front.`);
+  }
+
   // 5. The client, as fresh as the Wall's.
   const client = await fetchBounded(`${key.site}/client/toolaby.js`).then((r) => (r.ok && r.body ? r.body.toString('utf8') : null)).catch(() => null);
   if (client === null) warn('The Wall\'s current client could not be read to compare.');