toolaby 1.6.1 → 1.6.3

package/lib/check.js

@@ -3,12 +3,15 @@
 // client's freshness, the feature keys the code gates on against the tool's, the paywall's page, whether a copy has
 // checked in and whether the key is current, and — with --browser, where Playwright is installed — the extension
 // loaded in Chromium, its background answering and its own pages opening without an error.
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 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';
 
 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. */
+const TOOL_ID = /^[a-z0-9][a-z0-9-]{1,118}$/;
 const CODE = /\.(m?js|jsx|ts|tsx|html|vue|svelte)$/;
 const SKIP = new Set(['node_modules', '.git', 'dist', 'build', '.output', '.wxt', '.plasmo', '.next', 'coverage']);
 const sha = (s) => createHash('sha256').update(s).digest('hex');
@@ -65,54 +68,63 @@ export async function runCheck({ dir: given, out, api, token, detectProject, wir
   const manifest = has('manifest.json') ? readJson(join(dir, 'manifest.json')) : null;
   if (has('manifest.json') && !manifest) { bad('manifest.json is not valid JSON.'); return false; }
   const configSource = ['manifest.config.ts', 'manifest.config.js', 'manifest.ts', 'src/manifest.ts'].find(has);
-  const project = detectProject({ has, packageJson: has('package.json') ? readJson(join(dir, 'package.json')) : null, manifest, manifestSource: configSource ? readFileSync(join(dir, configSource), 'utf8') : null, site: 'https://example.invalid', tree });
-  if (project.kind === 'unknown') { bad(`Not an extension project: no manifest.json at the top, and not WXT, CRXJS or Plasmo${project.foundManifest ? ` (there is a manifest at ${project.foundManifest}: run this with --into ${project.foundManifest.replace(/\/?manifest\.json$/, '') || '.'})` : ''}.`); return false; }
+  const readOr = (p, none = null) => { try { return readText(p); } catch { return none; } };
+  const project = detectProject({ has, packageJson: has('package.json') ? readJson(join(dir, 'package.json')) : null, manifest, manifestSource: configSource ? readOr(join(dir, configSource)) : null, site: 'https://example.invalid', tree });
+  if (project.kind === 'unknown') { bad(`Not an extension project: no manifest.json at the top, and not WXT, CRXJS or Plasmo${project.foundManifest ? ` (there is a manifest at ${oneLine(project.foundManifest)}: run this with --into ${oneLine(project.foundManifest.replace(/\/?manifest\.json$/, '')) || '.'})` : ''}.`); return false; }
   ok(project.kind === 'plain' ? 'A plain extension: manifest.json at the top.' : `A ${project.label} project.`);
 
   // 2. The Wall's files.
   const at = (f) => join(dir, `${project.codeDir}${f}`);
   const missing = ['toolaby.js', 'toolaby.config.js'].filter((f) => !existsSync(at(f)));
-  if (missing.length) { bad(`${missing.map((f) => `${project.codeDir}${f}`).join(' and ')} missing. Run \`npx toolaby wire <tool-id>\` here.`); return false; }
+  if (missing.length) { bad(`${missing.map((f) => `${project.codeDir}${f}`).join(' and ')} missing. Run \`npx -y toolaby@latest wire <tool-id>\` here.`); return false; }
   ok(`The Wall's files are in ${project.codeDir || 'the top folder'}.`);
 
-  // 3. The tool key, and the tool it names.
-  const keyText = readFileSync(at('toolaby.config.js'), 'utf8').match(KEY)?.[0];
+  // 3. The tool key, and the tool it names — from a file: a link to a device or a pipe is read as nothing.
+  const configText = readOr(at('toolaby.config.js'), '');
+  const keyText = configText.match(KEY)?.[0];
   const key = keyText ? decodeKey(keyText) : null;
-  if (!key) { bad('toolaby.config.js holds no tool key. Run `npx toolaby upgrade <tool-id>` here.'); return false; }
+  if (!key) { bad('toolaby.config.js holds no tool key. Run `npx -y toolaby@latest upgrade <tool-id>` here.'); return false; }
   const mode = keyText.split('_')[1];
+  // The key is the project's: the Wall it names is asked twice below, with no session, and its tool id goes into a path
+  // the developer's session asks of their own Wall. So only a Wall's address (lib/safe.js), and only a tool id. A cloned
+  // project's key sent the two requests wherever it named, and a tool id of ".." made the signed-in one a request for
+  // another route (25 Sep 2026).
+  if (!keySite(key.site) || !TOOL_ID.test(key.slug)) {
+    bad(`The tool key names ${JSON.stringify(key.slug)} at ${JSON.stringify(key.site)}, which is not a tool on a Wall: its address is https (http only on this machine) with nothing after the host, and its id lowercase letters, digits and dashes. Nothing was asked of it. \`npx -y toolaby@latest upgrade <tool-id>\` writes the tool's own key.`);
+    return false;
+  }
   ok(`The tool key names ${key.slug}, on ${mode === 'live' ? 'Live' : mode === 'test' ? 'Test' : 'a development Wall'} (${key.site}).`);
-  const pub = await fetch(`${key.site}/api/tools/${encodeURIComponent(key.slug)}`).then(async (r) => ({ status: r.status, json: await r.json().catch(() => null) })).catch((e) => ({ status: 0, json: null, error: e.message }));
+  const pub = await fetchBounded(`${key.site}/api/tools/${encodeURIComponent(key.slug)}`).then((r) => ({ status: r.status, json: jsonOf(r.body) })).catch(() => ({ status: 0, json: null }));
   const tool = pub.status === 200 ? pub.json : null;
-  if (!tool) bad(pub.status === 0 ? `The Wall at ${key.site} could not be reached.` : pub.status === 404 ? `The Wall does not sell ${key.slug}: deleted, switched off, or on the other side. \`npx toolaby tools${mode === 'live' ? ' --live' : ''}\` lists yours.` : `The Wall answered HTTP ${pub.status} for the tool.`);
+  if (!tool) bad(pub.status === 0 ? `The Wall at ${key.site} could not be reached.` : pub.status === 404 ? `The Wall does not sell ${key.slug}: deleted, switched off, or on the other side. \`npx -y toolaby@latest tools${mode === 'live' ? ' --live' : ''}\` lists yours.` : `The Wall answered HTTP ${pub.status} for the tool.`);
   else {
-    ok(`The Wall knows it: ${tool.name}.`);
+    ok(`The Wall knows it: ${oneLine(tool.name)}.`);
     const jwk = tool.publicKeyJwk ?? {};
-    if (key.x && jwk.x && (key.x !== jwk.x || key.y !== jwk.y)) warn('The workspace\'s signing key was rotated after this key was written. Installed copies fetch the new one; `npx toolaby upgrade <tool-id>` writes it in.');
+    if (key.x && jwk.x && (key.x !== jwk.x || key.y !== jwk.y)) warn('The workspace\'s signing key was rotated after this key was written. Installed copies fetch the new one; `npx -y toolaby@latest upgrade <tool-id>` writes it in.');
   }
 
   // 4. The manifest, against the platform's own wiring rules: what wiring it again would add.
-  const configText = readFileSync(at('toolaby.config.js'), 'utf8');
   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));
-    if (needed.length) bad(`The manifest lacks what the Wall needs: ${needed.join('; ')}. \`npx toolaby upgrade ${key.slug}\` adds it.`);
+    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 toolaby upgrade ${key.slug}\` adds it.`);
+    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.`);
 
   // 5. The client, as fresh as the Wall's.
-  const client = await fetch(`${key.site}/client/toolaby.js`).then((r) => (r.ok ? r.text() : null)).catch(() => null);
+  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.');
-  else if (sha(client) !== sha(readFileSync(at('toolaby.js'), 'utf8'))) warn(`toolaby.js is not the Wall's current client. \`npx toolaby upgrade ${key.slug}\` replaces it (your own files stay).`);
+  else if (sha(client) !== sha(readOr(at('toolaby.js'), ''))) warn(`toolaby.js is not the Wall's current client. \`npx -y toolaby@latest upgrade ${key.slug}\` replaces it (your own files stay).`);
   else ok('toolaby.js is the Wall\'s current client.');
 
   // 6. The features the code gates on, against the tool's; and the page showPaywall() opens.
-  const sources = sourceFiles(dir).map((f) => readFileSync(f, 'utf8'));
+  const sources = sourceFiles(dir).map((f) => { try { return readText(f); } catch { return ''; } });
   if (project.manifestFile && manifest && sources.some((s) => /\bshowPaywall\s*\(/.test(withoutComments(s)))) {
     const pages = [manifest.action?.default_popup ? 'toolaby-popup.html' : null, (manifest.side_panel?.default_path || manifest.sidebar_action?.default_panel) ? 'toolaby-sidepanel.html' : null].filter(Boolean);
     const absent = pages.filter((p) => !existsSync(join(dir, `${project.popupDir}${p}`)));
-    if (absent.length) warn(`The code calls toolaby.showPaywall(), which opens ${absent.join(' and ')}, and the extension has no such page: the paywall opens the buyer page in a new tab instead. \`npx toolaby upgrade ${key.slug}\` writes ${absent.length > 1 ? 'them' : 'it'}; your pages stay in front.`);
+    if (absent.length) warn(`The code calls toolaby.showPaywall(), which opens ${absent.join(' and ')}, and the extension has no such page: the paywall opens the buyer page in a new tab instead. \`npx -y toolaby@latest upgrade ${key.slug}\` writes ${absent.length > 1 ? 'them' : 'it'}; your pages stay in front.`);
   }
   if (tool) {
     const used = new Set();
@@ -134,7 +146,7 @@ export async function runCheck({ dir: given, out, api, token, detectProject, wir
     else if (facts?.ok) warn('No copy has checked in yet: load it at chrome://extensions and open it once.');
     // The key carries what the Free plan holds and the kind of plan sold: a change since it was written leaves it behind.
     const current = facts?.ok ? facts.json?.toolKey : null;
-    if (typeof current === 'string' && current.split('_')[1] === mode && current !== keyText) warn(`The tool key in toolaby.config.js is older than the Wall's: what the Free plan holds, the plans or the signing key changed since it was written. \`npx toolaby upgrade ${key.slug}\` writes the current one.`);
+    if (typeof current === 'string' && current.split('_')[1] === mode && current !== keyText) warn(`The tool key in toolaby.config.js is older than the Wall's: what the Free plan holds, the plans or the signing key changed since it was written. \`npx -y toolaby@latest upgrade ${key.slug}\` writes the current one.`);
   }
 
   // 8. In a browser: the background answers.
@@ -168,7 +180,7 @@ async function browserCheck({ dir, project, manifest, ok, warn, bad }) {
       new Promise((r) => setTimeout(() => r('timeout'), 8000)),
     ])).catch((e) => `error: ${e.message}`);
     if (answer && answer !== 'timeout' && !String(answer).startsWith('error')) ok('The background answers the Wall\'s client: its listeners registered.');
-    else bad(`The background did not answer (${answer ?? 'nothing'}): its module threw while loading, so none of its listeners registered.`);
+    else bad(`The background did not answer (${oneLine(answer ?? 'nothing')}): its module threw while loading, so none of its listeners registered.`);
     await page.close().catch(() => {});
     // The extension's own pages, each opened in a tab: one whose script throws is a popup that opens blank.
     const own = [shipped?.action?.default_popup, shipped?.side_panel?.default_path].filter((p, i, all) => typeof p === 'string' && p && all.indexOf(p) === i);
@@ -179,12 +191,13 @@ async function browserCheck({ dir, project, manifest, ok, warn, bad }) {
       await tab.goto(`chrome-extension://${id}/${p}`).catch((e) => errors.push(e.message));
       await tab.waitForTimeout(1500);
       await tab.close().catch(() => {});
-      if (errors.length) bad(`${p} threw when it opened: ${errors[0]}`);
-      else ok(`${p} opens without an error.`);
+      if (errors.length) bad(`${oneLine(p)} threw when it opened: ${oneLine(errors[0])}`);
+      else ok(`${oneLine(p)} opens without an error.`);
     }
   } finally {
     await ctx.close().catch(() => {});
   }
 }
 
-function readJsonSafe(p) { try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return null; } }
+function readJsonSafe(p) { try { return JSON.parse(readText(p)); } catch { return null; } }
+function jsonOf(body) { try { return body ? JSON.parse(body.toString('utf8')) : null; } catch { return null; } }

package/lib/mcp.js

@@ -1,6 +1,6 @@
 // `toolaby mcp`: the Wall for coding agents, as a Model Context Protocol server on stdio.
 //
-// An agent (Claude Code, Cursor, Codex, any MCP client) starts it — `claude mcp add toolaby -- npx -y toolaby mcp` —
+// An agent (Claude Code, Cursor, Codex, any MCP client) starts it — `claude mcp add toolaby -- npx -y toolaby@latest mcp` —
 // and gets tools to read and change the developer's tools on the Wall: what the Free plan holds, features, plans,
 // grants, and the docs. It acts with the session `toolaby login` stored, on Test unless started with --live, through
 // the same routes and the same checks as the dashboard.
@@ -10,17 +10,34 @@
 // them) to a command line that has none and that the Wall also serves as one tarball; this is the stdio transport and
 // the tools capability exactly as the specification words them. Nothing but protocol messages goes to stdout.
 
+import { fetchBounded } from './safe.js';
+
 const PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05'];
+/**
+ * A tool id as the Wall makes them. Checked before it goes into a path: `..`, encoded or not, is a path the address
+ * resolves away, and `/api/cli/tools/../x` asked for `/api/cli/x` (25 Sep 2026).
+ */
+const TOOL_ID = /^[a-z0-9][a-z0-9-]{1,118}$/;
+
+/**
+ * What a tool does, as the specification's annotations say it (2025-03-26 on), for a client deciding what it may run
+ * without asking: a read changes nothing, a write changes the developer's own workspace — destructive where it takes
+ * away or gives away (what the Free plan holds, the feature list, access to someone), idempotent where a second call
+ * changes nothing more. Every tool acts on that workspace on the Wall and nothing beyond it. The writes carried no
+ * annotations, and a client took them for whatever its defaults were (25 Sep 2026).
+ */
+const READS = { readOnlyHint: true, openWorldHint: false };
 
 /** The tools, with JSON Schema for their arguments, and what each calls on the Wall. */
 function toolsFor(side) {
-  const tool = { type: 'string', description: 'The tool id, as `toolaby_list_tools` gives it (like "acme--word-counter").' };
+  const tool = { type: 'string', pattern: TOOL_ID.source, description: 'The tool id, as `toolaby_list_tools` gives it (like "acme--word-counter").' };
   return [
     {
       name: 'toolaby_whoami',
       title: 'Who is signed in',
       description: `The developer signed in to the ${side} Wall, and their workspaces.`,
       inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+      annotations: READS,
       run: (_a, api) => api('/api/cli/me'),
     },
     {
@@ -28,6 +45,7 @@ function toolsFor(side) {
       title: 'List tools',
       description: `Every tool in the developer's workspaces on the ${side} Wall, with the id the other tools take.`,
       inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+      annotations: READS,
       run: (_a, api) => api('/api/cli/tools'),
     },
     {
@@ -35,12 +53,13 @@ function toolsFor(side) {
       title: 'Read a tool',
       description: `One tool on the ${side} Wall: what the Free plan holds (freePlan.holds, in a sentence), its features, its plans with what each unlocks, its tool key, and its extension: identityId is the id of every copy whose manifest has the tool's key (such a copy needs no binding, so boundId stays null), checkedInAt says whether one has checked in, inUse which builds. Then the addresses of its pages.`,
       inputSchema: { type: 'object', properties: { tool }, required: ['tool'], additionalProperties: false },
+      annotations: READS,
       run: (a, api) => api(`/api/cli/tools/${encodeURIComponent(a.tool)}`),
     },
     {
       name: 'toolaby_create_tool',
       title: 'Create a tool',
-      description: `A new tool on the ${side} Wall. Its Free plan holds everything until access is set. Then wire an extension to it: \`npx toolaby create <id>\` for a new one, \`npx toolaby wire <id>\` for an existing one.`,
+      description: `A new tool on the ${side} Wall. This changes what the developer's own workspace sells: one more tool. Its Free plan holds everything until access is set. Then wire an extension to it: \`npx -y toolaby@latest create <id>\` for a new one, \`npx -y toolaby@latest wire <id>\` for an existing one.`,
       inputSchema: {
         type: 'object',
         properties: {
@@ -52,12 +71,13 @@ function toolsFor(side) {
         required: ['name'],
         additionalProperties: false,
       },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       run: (a, api) => api('/api/cli/tools', { method: 'POST', body: a }),
     },
     {
       name: 'toolaby_set_access',
       title: 'Set what the Free plan holds',
-      description: 'What a buyer gets before paying: "open" (the tool\'s use, unlimited), "free_uses" (a number of uses per device, counted by gate() without a feature), or "paid" (nothing before a plan). Whichever it is, a feature a plan sells (not marked free) is refused until bought. signInRequired asks for an account first. Takes effect on every device at its next check. The answer says when the tool key changed: `npx toolaby upgrade <id>` then writes the new one.',
+      description: 'What a buyer gets before paying: "open" (the tool\'s use, unlimited), "free_uses" (a number of uses per device, counted by gate() without a feature), or "paid" (nothing before a plan). This changes access in the developer\'s own workspace, for every buyer of the tool. Whichever it is, a feature a plan sells (not marked free) is refused until bought. signInRequired asks for an account first. Takes effect on every device at its next check. The answer says when the tool key changed: `npx -y toolaby@latest upgrade <id>` then writes the new one.',
       inputSchema: {
         type: 'object',
         properties: {
@@ -69,12 +89,13 @@ function toolsFor(side) {
         required: ['tool', 'access'],
         additionalProperties: false,
       },
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
       run: ({ tool: t, ...rest }, api) => api(`/api/cli/tools/${encodeURIComponent(t)}/access`, { method: 'POST', body: rest }),
     },
     {
       name: 'toolaby_set_features',
       title: 'Set features, and the plans that unlock them',
-      description: 'The tool\'s whole feature list (it replaces the current one: send the features it has too), and which plans unlock which. A feature\'s key is what the extension passes to gate({ feature }) and has(). A feature marked free is on the Free plan too; one that is not free and that no plan unlocks is refused to everyone. The plans must exist first (toolaby_add_plan); a plan not named in `plans` keeps what it unlocks.',
+      description: 'The tool\'s whole feature list (it replaces the current one: send the features it has too), and which plans unlock which. This changes billing in the developer\'s own workspace: what every plan of the tool sells. A feature\'s key is what the extension passes to gate({ feature }) and has(). A feature marked free is on the Free plan too; one that is not free and that no plan unlocks is refused to everyone. The plans must exist first (toolaby_add_plan); a plan not named in `plans` keeps what it unlocks.',
       inputSchema: {
         type: 'object',
         properties: {
@@ -102,12 +123,13 @@ function toolsFor(side) {
         required: ['tool', 'features'],
         additionalProperties: false,
       },
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
       run: ({ tool: t, ...rest }, api) => api(`/api/cli/tools/${encodeURIComponent(t)}/features`, { method: 'POST', body: rest }),
     },
     {
       name: 'toolaby_add_plan',
       title: 'Add a plan',
-      description: `A plan buyers can buy: a Price on the workspace's Stripe account (${side === 'Test' ? 'on Test, its test account' : 'on Live, the connected account'}). "one_time" makes a lifetime licence; "subscription" bills monthly or yearly. Answers with the plan: its id (the tool's first plan is "default"), which openPaymentPage(id) takes, and its name as buyers see it, the name given and the kind ("Pro · Lifetime"). Then say what it unlocks with toolaby_set_features. The answer says when the tool key changed (the first subscription plan changes it): \`npx toolaby upgrade <id>\` then writes the new one.`,
+      description: `A plan buyers can buy: a Price on the workspace's Stripe account (${side === 'Test' ? 'on Test, its test account' : 'on Live, the connected account'}). This changes billing in the developer's own workspace. "one_time" makes a lifetime licence; "subscription" bills monthly or yearly. Answers with the plan: its id (the tool's first plan is "default"), which openPaymentPage(id) takes, and its name as buyers see it, the name given and the kind ("Pro · Lifetime"). Then say what it unlocks with toolaby_set_features. The answer says when the tool key changed (the first subscription plan changes it): \`npx -y toolaby@latest upgrade <id>\` then writes the new one.`,
       inputSchema: {
         type: 'object',
         properties: {
@@ -124,18 +146,20 @@ function toolsFor(side) {
         required: ['tool', 'billing', 'amount', 'currency'],
         additionalProperties: false,
       },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       run: ({ tool: t, ...rest }, api) => api(`/api/cli/tools/${encodeURIComponent(t)}/plans`, { method: 'POST', body: rest }),
     },
     {
       name: 'toolaby_grant',
       title: 'Grant access',
-      description: 'Access to the tool without paying: to test a paid feature on Test, or for a reviewer. An address with no account gets one; the grant applies once that person signs in to the extension with it (the link arrives by email), so testing a paid feature this way needs a person for a moment. For a number of days, or until revoked. On the Free plan a workspace holds 100 grants and other passes at once.',
+      description: 'Access to the tool without paying: to test a paid feature on Test, or for a reviewer. This changes access in the developer\'s own workspace: the person gets the paid features, and each call is another grant. An address with no account gets one; the grant applies once that person signs in to the extension with it (the link arrives by email), so testing a paid feature this way needs a person for a moment. For a number of days, or until revoked. On the Free plan a workspace holds 100 grants and other passes at once.',
       inputSchema: {
         type: 'object',
         properties: { tool, email: { type: 'string' }, days: { type: 'integer', minimum: 1, maximum: 3650, description: 'Optional: how long. Default: until revoked.' } },
         required: ['tool', 'email'],
         additionalProperties: false,
       },
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       run: ({ tool: t, ...rest }, api) => api(`/api/cli/tools/${encodeURIComponent(t)}/grants`, { method: 'POST', body: rest }),
     },
     {
@@ -143,6 +167,7 @@ function toolsFor(side) {
       title: 'Read the docs',
       description: 'The Wall\'s docs as Markdown. Without a page: the index, every page with what it covers. With a page (like "gating", "pricing", "reference/client"): that page.',
       inputSchema: { type: 'object', properties: { page: { type: 'string' } }, additionalProperties: false },
+      annotations: READS,
       run: (a, _api, docs) => docs(a.page),
     },
   ];
@@ -168,15 +193,22 @@ export function runMcp({ version, side, wall, api, token }) {
     const clean = typeof page === 'string' ? page.replace(/^\/+|\.md$|\/+$/g, '').replace(/^docs\//, '') : '';
     if (clean && !/^[a-z0-9-]+(\/[a-z0-9-]+)*$/.test(clean)) return { ok: false, status: 400, json: { message: 'A page is a path like "gating" or "reference/client".' } };
     const url = clean ? `${wall}/docs/${clean}.md` : `${wall}/llms.txt`;
-    const res = await fetch(url).catch((e) => ({ ok: false, status: 0, text: async () => e.message }));
-    const text = await res.text();
+    // The Wall's own pages, a few megabytes at most: a redirect elsewhere handed an agent any host's page as the docs (25 Sep 2026).
+    const res = await fetchBounded(url, { limit: 4 * 1024 * 1024 }).catch(() => ({ ok: false, status: 0, body: null }));
+    if (res.ok && !res.body) return { ok: false, status: 413, json: { message: 'The docs page is larger than any the Wall serves.' } };
+    const text = res.body ? res.body.toString('utf8') : '';
     return res.ok ? { ok: true, status: res.status, text } : { ok: false, status: res.status, json: { message: res.status === 404 ? `No docs page "${clean}". Call toolaby_docs without a page for the index.` : `The docs answered HTTP ${res.status}.` } };
   };
   const call = async (name, args) => {
     const t = tools.find((x) => x.name === name);
     if (!t) return { error: { code: -32602, message: `Unknown tool: ${name}` } };
+    // Arguments are an object, or none: anything else threw before the answer, and the request went unanswered.
+    if (args !== undefined && (args === null || typeof args !== 'object' || Array.isArray(args))) return { error: { code: -32602, message: 'Arguments are an object.' } };
+    if (args && 'tool' in args && (typeof args.tool !== 'string' || !TOOL_ID.test(args.tool))) {
+      return { result: { content: [{ type: 'text', text: 'A tool id is lowercase letters, digits and dashes, as toolaby_list_tools gives it.' }], isError: true } };
+    }
     if (name !== 'toolaby_docs' && !token()) {
-      return { result: { content: [{ type: 'text', text: `Not signed in to the ${side} Wall (${wall}). Run \`npx toolaby login${side === 'Live' ? ' --live' : ''}\` in a terminal, then call this again.` }], isError: true } };
+      return { result: { content: [{ type: 'text', text: `Not signed in to the ${side} Wall (${wall}). Run \`npx -y toolaby@latest login${side === 'Live' ? ' --live' : ''}\` in a terminal, then call this again.` }], isError: true } };
     }
     try {
       return { result: resultOf(await t.run(args ?? {}, api, docs)) };
@@ -197,7 +229,7 @@ export function runMcp({ version, side, wall, api, token }) {
           protocolVersion: PROTOCOL_VERSIONS.includes(asked) ? asked : PROTOCOL_VERSIONS[0],
           capabilities: { tools: { listChanged: false } },
           serverInfo: { name: 'toolaby', title: 'Toolaby Wall', version },
-          instructions: `The Toolaby Wall (${side}, ${wall}): accounts, licences, subscriptions and the paywall for Chrome extensions. Read a tool with toolaby_get_tool before changing it; the extension gates paid work with toolaby.gate({ feature }) and each feature key must exist on the tool (toolaby_set_features). Wire files with the shell: npx toolaby create|wire|upgrade <id>, check with npx toolaby check. toolaby_docs reads the docs.`,
+          instructions: `The Toolaby Wall (${side}, ${wall}): accounts, licences, subscriptions and the paywall for Chrome extensions. Read a tool with toolaby_get_tool before changing it; the extension gates paid work with toolaby.gate({ feature }) and each feature key must exist on the tool (toolaby_set_features). Wire files with the shell: npx -y toolaby@latest create|wire|upgrade <id>, check with npx -y toolaby@latest check. toolaby_docs reads the docs.`,
         } });
       }
       case 'notifications/initialized':
@@ -216,7 +248,7 @@ export function runMcp({ version, side, wall, api, token }) {
     }
   };
 
-  log(`${side} · ${wall} · ${token() ? 'signed in' : 'not signed in: tools ask for `npx toolaby login`'}`);
+  log(`${side} · ${wall} · ${token() ? 'signed in' : 'not signed in: tools ask for `npx -y toolaby@latest login`'}`);
   let buffer = '';
   process.stdin.setEncoding('utf8');
   process.stdin.on('data', (chunk) => {

package/lib/project.js

@@ -120,11 +120,13 @@ export function detectProject(o) {
     if (crxjs && !has('manifest.json')) {
         const configFile = first(has, ['manifest.config.ts', 'manifest.config.js', 'manifest.ts', 'manifest.js', 'src/manifest.ts', 'src/manifest.js']);
         const source = o.manifestSource ?? '';
-        const declared = source.match(/default_popup:\s*['"]([^'"]+)['"]/)?.[1] ?? null;
+        // A name as one line of a path: read across a line break or a backslash, a project's config drew lines of its own
+        // into the snippets the command prints and the dashboard shows (25 Sep 2026).
+        const declared = source.match(/default_popup:\s*['"]([^'"\\\r\n]+)['"]/)?.[1] ?? null;
         const appPopup = declared && declared !== 'toolaby-popup.html' ? declared : null;
-        const declaredPanel = source.match(/default_path:\s*['"]([^'"]+)['"]/)?.[1] ?? null;
+        const declaredPanel = source.match(/default_path:\s*['"]([^'"\\\r\n]+)['"]/)?.[1] ?? null;
         const appSidePanel = declaredPanel && declaredPanel !== 'toolaby-sidepanel.html' ? declaredPanel : null;
-        const worker = source.match(/service_worker:\s*['"]([^'"]+)['"]/)?.[1] ?? first(has, ['src/background.ts', 'src/background.js', 'background.ts', 'background.js']);
+        const worker = source.match(/service_worker:\s*['"]([^'"\\\r\n]+)['"]/)?.[1] ?? first(has, ['src/background.ts', 'src/background.js', 'background.ts', 'background.js']);
         const workerFile = worker ?? 'src/background.ts';
         const workerLines = `import { toolaby } from '${importPath(workerFile)}';\n\ntoolaby.startBackground();\n`;
         const code = [