launchprep 0.0.1 → 0.2.0

package/README.md

@@ -1,20 +1,84 @@
-# Launchprep
+# launchprep
 
-**Launch readiness checker.** Reads your code and tells you what will break.
+Reads your code and tells you what will break before your users find out.
 
-288 checks — but it works out what you actually built before running any of
-them, and tells you which ones it skipped and why. You are not building
-Instagram; you will not hear about Instagram's problems.
+```bash
+npx launchprep            # the free checks — runs here, uploads nothing
+npx launchprep login      # store the licence key from your email
+npx launchprep deep       # the paid scan — asks before sending anything
+npx launchprep whoami     # scans remaining
+```
+
+No signup. No dashboard. Nothing added to your repo.
+
+## What it does
+
+288 checks — but it works out what you built **before** running any of them, so
+you are not told about problems you cannot have. A static site is asked 48
+questions; a multi-tenant SaaS with payments and AI is asked 158.
+
+Every check ends in one of four states, and you are shown all four:
+
+| | |
+|---|---|
+| **pass** | applicable, and satisfied |
+| **fail** | applicable, and violated — a finding, with a file, a line and the fix |
+| **skipped** | does not apply to you — **listed, with the reason** |
+| **unknown** | cannot be determined from the code — becomes a question, never a CRITICAL |
+
+That skipped list is the point. "47 checks skipped, you are not multi-tenant" is
+what should make you trust the 12 that did fire.
+
+## The free scan cannot touch your code, and cannot phone home
+
+The scanner reads. It has no ability to write files, run commands, or open a
+network connection — and that is enforced by a build step rather than promised:
+
+```bash
+node scripts/verify-readonly.mjs
+```
+
+That script ships with the package. Run it yourself. It fails if anything under
+`src/` gains the ability to write, execute, or reach the network — **and if
+anything under `src/` so much as imports a file from outside it.**
+
+That last part matters. `launchprep login` writes a key to disk and
+`launchprep deep` uploads code. Both are real. Both live in `net/`, not `src/`,
+so the scanner cannot borrow a capability it does not have. Without that check
+this script could print "read-only verified" while the scanner was perfectly
+able to upload your repository — a promise that passes its own test and is
+false, which is worse than no promise at all.
 
-- Runs entirely on your machine. Reads your files, changes none of them, uploads nothing.
-- Covers Next.js, Express, Django, Rails, Laravel, Supabase, Stripe, and mobile.
-- Every finding carries a file, a line, and the fix.
+So the difference is visible in the file tree:
 
 ```
-npx launchprep
+src/   the free scanner   reads. writes nothing. connects to nothing.
+net/   the paid client    writes your key. uploads a digest. asks first.
 ```
 
-**This package is a placeholder while the tool is finished.**
-See [launchprep.dev](https://launchprep.dev).
+## The deep scan does send code — and tells you before it does
+
+`launchprep deep` sends a digest of the security-relevant files to
+launchprep.dev, and from there to Anthropic, so a model can read them. Before a
+single byte leaves it shows you how many files, roughly how many tokens, and
+where they are going — and offers to list every file by name.
+
+Your code is held in memory for the scan and discarded. It is never written to
+disk, never logged, and never stored in a database. The findings are kept, so
+the report link keeps working, and that link expires.
+
+If there is no terminal — CI, a script — it refuses rather than assuming yes.
+
+## Free and paid
+
+Everything above is free, unlimited, forever — every check a program can make on
+its own.
+
+The paid tier ($29, five deep scans) is the 173 checks that need a model to
+reason about the code: whether one customer can reach another's data, whether
+your tenants are really separated, what happens to information you promised to
+delete. See <https://launchprep.dev>.
+
+## Licence
 
-MIT licensed.
+MIT

package/bin/launchprep.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+// The entry point, and a deliberately thin one.
+//
+// `launchprep` with no subcommand is the free scanner: src/, which cannot
+// write, execute, or open a connection, and a build step proves it. Nothing in
+// src/ may even import from out here - the guard checks that too, because a
+// promise that passes its own test and is false is worse than no promise.
+//
+// login / logout / deep are the paid half. They write a key to disk and upload
+// a digest, and they live in net/ so that difference is visible in the file
+// tree rather than buried in a privacy policy.
+import { BRAND } from '../src/brand.mjs';
+
+const argv = process.argv.slice(2);
+const cmd = argv[0];
+const KNOWN = new Set(['login', 'logout', 'deep', 'whoami', 'help', '--help', '-h']);
+
+// Anything that reaches here uncaught would otherwise print a Node stack
+// trace at someone who paid $29 and cannot read one. A network that is down
+// is not a bug in their project, and it should not look like one.
+try {
+  if (!KNOWN.has(cmd)) {
+    // free scan - src/ only, nothing from net/ is loaded at all
+    await import('../src/index.mjs');
+  } else {
+    const { run } = await import('../net/commands.mjs');
+    await run(cmd, argv.slice(1));
+  }
+} catch (e) {
+  const msg = e?.message || String(e);
+  process.stderr.write(`\n  \x1b[31m${msg}\x1b[0m\n`);
+  if (/could not reach|did not answer/i.test(msg)) {
+    process.stderr.write(`  \x1b[2mThe free checks do not need the network. Run \x1b[0mnpx ${BRAND.slug}\x1b[2m on its own.\x1b[0m\n`);
+    process.stderr.write(`  \x1b[2mIf this keeps happening, mail ${BRAND.email} — your scans are not spent unless a scan runs.\x1b[0m\n`);
+  }
+  process.stderr.write('\n');
+  process.exit(1);
+}

package/net/client.mjs

@@ -0,0 +1,41 @@
+// Talking to launchprep.dev. The only file in the CLI that opens a connection.
+import { BRAND } from '../src/brand.mjs';
+const BASE = process.env.LAUNCHPREP_API || BRAND.api;
+
+async function call(path, { key, body, method = 'POST' } = {}) {
+  let res;
+  try {
+    res = await fetch(BASE + path, {
+      method,
+      headers: {
+        ...(key ? { authorization: `Bearer ${key}` } : {}),
+        ...(body ? { 'content-type': 'application/json' } : {}),
+      },
+      body: body ? JSON.stringify(body) : undefined,
+      // A deep scan is minutes of model time, not seconds. But it is not
+      // forever either - API-010, our own rule: nothing outbound should be able
+      // to hang indefinitely.
+      signal: AbortSignal.timeout(Number(process.env.LAUNCHPREP_TIMEOUT_MS || 900_000)),
+    });
+  } catch (e) {
+    if (e.name === 'TimeoutError') throw new Error('launchprep.dev did not answer in time');
+    throw new Error(`could not reach ${BASE} — ${e.message}`);
+  }
+  const text = await res.text();
+  let data = null;
+  try { data = text ? JSON.parse(text) : null; } catch {}
+  return { status: res.status, ok: res.ok, data, raw: text };
+}
+
+export const validate = (key) => call('/v1/validate', { key });
+
+export const deepScan = ({ key, digest, profile, ruleIds, appName, idempotencyKey }) =>
+  call('/v1/scan', { key, body: {
+    digest: digest.text,
+    profile,
+    rule_ids: ruleIds,
+    app_name: appName,
+    idempotency_key: idempotencyKey,
+  }});
+
+export { BASE };

package/net/commands.mjs

@@ -0,0 +1,166 @@
+// login · logout · whoami · deep
+import { createInterface } from 'node:readline';
+import { randomUUID, createHash } from 'node:crypto';
+import { basename, resolve } from 'node:path';
+
+import { BRAND } from '../src/brand.mjs';
+import { scanRepo } from '../src/fs-scan.mjs';
+import { detectProfile, toGateProfile } from '../src/detect.mjs';
+import { gate } from '../src/gate.mjs';
+import { buildDigest } from '../src/digest.mjs';
+import { save, load, clear, FILE } from './credentials.mjs';
+import { confirmUpload } from './consent.mjs';
+import { validate, deepScan, BASE } from './client.mjs';
+
+const C = { b:'\x1b[1m', d:'\x1b[2m', g:'\x1b[90m', o:'\x1b[38;5;209m',
+            grn:'\x1b[32m', red:'\x1b[31m', yel:'\x1b[33m', off:'\x1b[0m' };
+const SEV = { critical:[C.red,'CRITICAL'], high:[C.yel,'HIGH'], medium:['\x1b[34m','MEDIUM'], low:[C.g,'LOW'] };
+const flag = (a, n) => a.includes('--' + n);
+
+const prompt = (q) => new Promise((r) => {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  rl.question(q, (a) => { rl.close(); r(a.trim()); });
+});
+
+async function login(args) {
+  let key = args.find(a => a.startsWith('lp_'));
+  if (!key) {
+    if (!process.stdin.isTTY) { console.error('  pass the key as an argument, or set LAUNCHPREP_KEY'); process.exit(1); }
+    console.log(`\n${C.b}${BRAND.name}${C.off} ${C.d}— paste the key from your email${C.off}\n`);
+    key = await prompt('  key: ');
+  }
+  if (!/^lp_/.test(key)) { console.error(`\n  ${C.red}That does not look like a licence key.${C.off} They start with lp_\n`); process.exit(1); }
+
+  const r = await validate(key);
+  if (r.status === 429) { console.error(`\n  ${C.red}Too many requests.${C.off} ${C.d}Try again in ${backoff(r)}.${C.off}\n`); process.exit(1); }
+  if (r.status === 401) { console.error(`\n  ${C.red}That key is not recognised.${C.off}\n`); process.exit(1); }
+  if (r.status === 403) { console.error(`\n  ${C.red}That key has been revoked.${C.off}\n`); process.exit(1); }
+  if (!r.ok) { console.error(`\n  ${C.red}Could not check the key${C.off} ${C.d}(${r.status})${C.off}\n`); process.exit(1); }
+
+  const path = save({ key, email: r.data.email });
+  console.log(`\n  ${C.grn}Signed in${C.off} as ${r.data.email}`);
+  console.log(`  ${C.d}${r.data.scansRemaining} of ${r.data.scansLimit} deep scans left${C.off}`);
+  console.log(`  ${C.d}key stored in ${path}, readable only by you${C.off}\n`);
+}
+
+function logout() {
+  console.log(clear() ? `\n  ${C.grn}Signed out.${C.off} ${C.d}${FILE} removed${C.off}\n`
+                      : `\n  ${C.d}You were not signed in.${C.off}\n`);
+}
+
+async function whoami() {
+  const c = load();
+  if (!c) { console.log(`\n  ${C.d}Not signed in. Run: ${C.off}npx ${BRAND.slug} login\n`); return; }
+  const r = await validate(c.key);
+  if (!r.ok) { console.log(`\n  ${C.red}The stored key is no longer valid.${C.off}\n`); return; }
+  console.log(`\n  ${r.data.email}`);
+  console.log(`  ${C.d}${r.data.scansRemaining} of ${r.data.scansLimit} deep scans left · key from ${c.source}${C.off}\n`);
+}
+
+async function deep(args) {
+  const target = resolve(args.find(a => !a.startsWith('-')) || process.cwd());
+  const c = load();
+  if (!c) {
+    console.error(`\n  ${C.red}Not signed in.${C.off}`);
+    console.error(`  ${C.d}Buy a key at https://${BRAND.slug}.dev, then: ${C.off}npx ${BRAND.slug} login\n`);
+    process.exit(1);
+  }
+
+  console.log(`\n${C.b}${BRAND.name.toUpperCase()} DEEP${C.off} ${C.d}${target}${C.off}\n`);
+
+  const repo = scanRepo(target, { maxFiles: 12000 });
+  const profile = toGateProfile(detectProfile(repo));
+  const g = gate(profile);
+  const tier2 = g.evaluated.filter(r => r.tier === 2);
+  if (!tier2.length) {
+    console.log(`  ${C.grn}No deep checks apply to this project.${C.off}`);
+    console.log(`  ${C.d}Nothing was uploaded and no scan was used.${C.off}\n`);
+    return;
+  }
+  const digest = buildDigest(repo, { maxTokens: 150_000, profile });
+
+  console.log(`  ${C.g}what it is  ${C.off}${profile.surface} · ${[profile.stack.framework, profile.stack.database, profile.stack.host].filter(Boolean).join(' · ') || '—'}`);
+  console.log(`  ${C.g}deep checks ${C.off}${tier2.length} of ${g.evaluated.length + g.skipped.length} apply`);
+
+  const okToSend = await confirmUpload({ digest, host: new URL(BASE).host, assumeYes: flag(args, 'yes') });
+  if (!okToSend) process.exit(1);
+
+  // Same repo, same rules, same content = same request. If the connection drops
+  // and this is run again, the server recognises it and does not charge a
+  // second scan.
+  const idem = createHash('sha256')
+    .update(digest.text).update(tier2.map(r => r.id).join(',')).digest('hex').slice(0, 32);
+
+  console.log(`  ${C.d}scanning — this takes a few minutes${C.off}`);
+  const r = await deepScan({ key: c.key, digest, profile,
+    ruleIds: tier2.map(x => x.id), appName: basename(target), idempotencyKey: idem });
+
+  if (r.status === 429) {
+    console.error(`\n  ${C.red}Too many requests.${C.off} ${C.d}Try again in ${backoff(r)}. No scan was used.${C.off}\n`);
+    process.exit(1);
+  }
+  if (r.status === 402) {
+    console.error(`\n  ${C.red}No deep scans left${C.off} ${C.d}(${r.data?.used}/${r.data?.limit} used)${C.off}\n`);
+    process.exit(1);
+  }
+  if (r.status === 413) {
+    console.error(`\n  ${C.red}This project is too large for one scan.${C.off}`);
+    console.error(`  ${C.d}${r.data?.tokens?.toLocaleString()} tokens, limit ${r.data?.limit?.toLocaleString()}. No scan was used.${C.off}\n`);
+    process.exit(1);
+  }
+  if (!r.ok) {
+    console.error(`\n  ${C.red}The scan did not run${C.off} ${C.d}(${r.status})${C.off} ${r.data?.detail || r.data?.error || ''}`);
+    if (r.data?.refunded) console.error(`  ${C.grn}Your scan was not used.${C.off}`);
+    console.error('');
+    process.exit(1);
+  }
+
+  const findings = r.data.findings || [];
+  const rank = { critical:0, high:1, medium:2, low:3 };
+  findings.sort((a, b) => rank[a.severity] - rank[b.severity]);
+
+  console.log(`\n${C.b}Findings${C.off}  ${C.d}${findings.length}${C.off}\n`);
+  for (const f of findings.slice(0, 25)) {
+    const [col, label] = SEV[f.severity] || SEV.low;
+    console.log(`  ${col}${C.b}${label}${C.off}  ${f.title}`);
+    console.log(`  ${C.g}${f.file}:${f.line}${C.off}`);
+    console.log(`      ${f.detail}`);
+    console.log(`      ${C.grn}Fix${C.off}  ${f.fix}\n`);
+  }
+  if (r.data.report?.url) {
+    console.log(`${C.b}Your report${C.off}`);
+    console.log(`  ${C.o}${r.data.report.url}${C.off}`);
+    console.log(`  ${C.d}dated, shareable, and it expires in ${r.data.report.expiresInDays} days${C.off}\n`);
+  }
+  console.log(`  ${C.d}${r.data.scansRemaining} deep scan${r.data.scansRemaining === 1 ? '' : 's'} left${C.off}\n`);
+}
+
+function help() {
+  console.log(`
+${C.b}${BRAND.name}${C.off} ${C.d}${BRAND.tagline}${C.off}
+
+  ${C.b}npx ${BRAND.slug}${C.off} ${C.d}[path]${C.off}          the free checks — runs here, uploads nothing
+  ${C.b}npx ${BRAND.slug} login${C.off}            store the licence key from your email
+  ${C.b}npx ${BRAND.slug} whoami${C.off}           who you are signed in as, and scans left
+  ${C.b}npx ${BRAND.slug} logout${C.off}           forget the key
+  ${C.b}npx ${BRAND.slug} deep${C.off} ${C.d}[path]${C.off}     the paid scan — asks before sending anything
+
+  ${C.d}--yes${C.off}   skip the upload confirmation ${C.d}(for CI)${C.off}
+  ${C.d}--json${C.off}  machine readable ${C.d}(free scan only)${C.off}
+
+  ${C.d}https://${BRAND.slug}.dev${C.off}
+`);
+}
+
+const backoff = (r) => {
+  const s = Number(r.data?.retryAfter) || 60;
+  return s < 90 ? `${s} seconds` : `${Math.ceil(s / 60)} minutes`;
+};
+
+export async function run(cmd, args) {
+  if (cmd === 'login')  return login(args);
+  if (cmd === 'logout') return logout();
+  if (cmd === 'whoami') return whoami();
+  if (cmd === 'deep')   return deep(args);
+  return help();
+}

package/net/consent.mjs

@@ -0,0 +1,57 @@
+// Nobody's code leaves their machine without them being told what and where.
+//
+// Every other AI tool uploads first and explains in a privacy policy. This is
+// the same principle the rest of the product runs on - shown, so you can
+// correct it - applied to the one moment it matters most.
+import { createInterface } from 'node:readline';
+
+const C = { b:'\x1b[1m', d:'\x1b[2m', o:'\x1b[38;5;209m', g:'\x1b[90m', off:'\x1b[0m' };
+
+function ask(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (a) => { rl.close(); resolve(a.trim().toLowerCase()); });
+  });
+}
+
+export async function confirmUpload({ digest, host, assumeYes = false, showFiles = false }) {
+  const files = digest.included.length;
+  const tokens = digest.tokens.toLocaleString();
+
+  console.log(`\n${C.b}Before this runs${C.off}\n`);
+  console.log(`  This sends ${C.b}${files} files${C.off} of your code ${C.d}(about ${tokens} tokens)${C.off}`);
+  console.log(`  to ${C.b}${host}${C.off}, and from there to Anthropic, so a model can read them.\n`);
+  console.log(`  ${C.g}Your code is not stored.${C.off} It is held in memory for the scan and discarded.`);
+  console.log(`  ${C.g}The findings are kept${C.off} — file names, line numbers, and what to fix —`);
+  console.log(`  so the report link keeps working. That link expires.\n`);
+  console.log(`  ${C.d}The free checks never do any of this. They run entirely on this machine.${C.off}\n`);
+
+  if (showFiles) {
+    console.log(`${C.b}What would be sent${C.off}`);
+    for (const f of digest.included.slice(0, 200))
+      console.log(`  ${C.g}${String(f.tokens).padStart(6)}${C.off}  ${f.path}`);
+    if (digest.included.length > 200)
+      console.log(`  ${C.d}… and ${digest.included.length - 200} more${C.off}`);
+    console.log('');
+  }
+
+  if (assumeYes) { console.log(`  ${C.d}--yes given, continuing.${C.off}\n`); return true; }
+
+  // No terminal (CI, a pipe) and no --yes: refuse rather than guess. Uploading
+  // someone's source because nobody was there to say no is not a default.
+  if (!process.stdin.isTTY) {
+    console.log(`  ${C.o}Not a terminal, so there is nobody to ask.${C.off}`);
+    console.log(`  ${C.d}Re-run with --yes if you meant this to be automatic.${C.off}\n`);
+    return false;
+  }
+
+  if (!showFiles) {
+    const list = await ask(`  List the files first? ${C.d}[y/N]${C.off} `);
+    if (list === 'y' || list === 'yes')
+      return confirmUpload({ digest, host, assumeYes, showFiles: true });
+  }
+  const go = await ask(`  Send them and run the deep scan? ${C.d}[y/N]${C.off} `);
+  const yes = go === 'y' || go === 'yes';
+  console.log(yes ? '' : `\n  ${C.d}Nothing was sent.${C.off}\n`);
+  return yes;
+}

package/net/credentials.mjs

@@ -0,0 +1,33 @@
+// Where the licence key lives.
+//
+// This file WRITES, which is why it is not in src/. The scanner has no such
+// ability and a build step proves it; these two commands do, and say so.
+import { readFileSync, writeFileSync, mkdirSync, rmSync, chmodSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export const DIR  = join(homedir(), '.launchprep');
+export const FILE = join(DIR, 'credentials');
+
+export function save({ key, email }) {
+  // 0700 / 0600. The key is a bearer token: anyone who can read the file can
+  // spend the scans. Other users on a shared machine should not be able to.
+  mkdirSync(DIR, { recursive: true, mode: 0o700 });
+  writeFileSync(FILE, JSON.stringify({ key, email, savedAt: new Date().toISOString() }, null, 2) + '\n',
+                { mode: 0o600 });
+  try { chmodSync(DIR, 0o700); chmodSync(FILE, 0o600); } catch {}
+  return FILE;
+}
+
+export function load() {
+  // An env var wins, so CI never needs a file on disk.
+  if (process.env.LAUNCHPREP_KEY) return { key: process.env.LAUNCHPREP_KEY.trim(), source: 'env' };
+  try {
+    const c = JSON.parse(readFileSync(FILE, 'utf8'));
+    return c.key ? { ...c, source: 'file' } : null;
+  } catch { return null; }
+}
+
+export function clear() {
+  try { rmSync(FILE); return true; } catch { return false; }
+}

package/package.json

@@ -1,13 +1,22 @@
 {
   "name": "launchprep",
-  "version": "0.0.1",
-  "description": "Launch readiness checker. Reads your code and tells you what will break. Coming soon.",
+  "version": "0.2.0",
+  "description": "Launch readiness checker. Reads your code and tells you what will break before your users find out.",
+  "type": "module",
   "bin": {
-    "launchprep": "bin/cli.js"
+    "launchprep": "./bin/launchprep.mjs"
   },
-  "type": "module",
-  "engines": {
-    "node": ">=18"
+  "files": [
+    "src",
+    "net",
+    "bin",
+    "scripts/verify-readonly.mjs",
+    "README.md"
+  ],
+  "scripts": {
+    "verify": "node scripts/verify-readonly.mjs",
+    "pretest": "node scripts/verify-readonly.mjs",
+    "test": "node test/run.mjs"
   },
   "keywords": [
     "security",
@@ -15,12 +24,18 @@
     "readiness",
     "scanner",
     "prelaunch",
-    "cli"
+    "cli",
+    "launch",
+    "checklist"
   ],
   "homepage": "https://launchprep.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/312labs/launchprep-app.git",
+    "directory": "cli"
+  },
   "license": "MIT",
-  "files": [
-    "bin",
-    "README.md"
-  ]
-}
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/verify-readonly.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// Fails the build if anything under src/ gains the ability to write, execute,
+// or phone home. Launchprep reads the user's codebase; it must never touch it.
+import { readdirSync, readFileSync } from 'node:fs';
+import { join, extname } from 'node:path';
+
+const SRC = new URL('../src/', import.meta.url).pathname;
+
+const FORBIDDEN = [
+  [/\bwriteFileSync\b|\bappendFileSync\b|\bwriteSync\b|\bcreateWriteStream\b/, 'file write'],
+  [/\bmkdirSync\b|\brmSync\b|\brmdirSync\b|\bunlinkSync\b|\btruncateSync\b/,   'file/dir mutation'],
+  [/\brenameSync\b|\bcopyFileSync\b|\bchmodSync\b|\bchownSync\b|\bsymlinkSync\b/, 'file metadata change'],
+  [/from\s+['"]node:child_process['"]|require\(['"]child_process['"]\)/,       'process execution'],
+  [/\bexecSync\b|\bspawnSync\b|\bexecFileSync\b/,                              'process execution'],
+  [/from\s+['"]node:(net|http|https|dgram|tls)['"]/,                           'network'],
+  [/\bfetch\s*\(/,                                                             'network'],
+];
+
+const files = [];
+(function walk(d) {
+  for (const e of readdirSync(d, { withFileTypes: true })) {
+    const p = join(d, e.name);
+    if (e.isDirectory()) walk(p);
+    else if (['.mjs', '.js', '.ts'].includes(extname(e.name))) files.push(p);
+  }
+})(SRC);
+
+let bad = 0;
+// A forbidden name appearing INSIDE a regex or a string is a pattern to search
+// for, not a call. Strip those before matching, or the scanner cannot contain a
+// check that looks for dangerous code.
+function stripLiterals(line) {
+  return line
+    .replace(/\/(?![*/])(?:\\.|\[[^\]]*\]|[^\\/\n])+\/[gimsuy]*/g, ' RE ')
+    .replace(/'(?:\\.|[^'\\])*'/g, " '' ")
+    .replace(/"(?:\\.|[^"\\])*"/g, ' "" ')
+    .replace(/`(?:\\.|[^`\\])*`/g, ' `` ');
+}
+
+for (const f of files) {
+  const text = readFileSync(f, 'utf8');
+  text.split('\n').forEach((raw, i) => {
+    if (raw.trimStart().startsWith('//')) return;          // comments describe, they don't run
+    const line = stripLiterals(raw);
+    for (const [re, label] of FORBIDDEN) {
+      if (re.test(line)) {
+        console.error(`  ${f.replace(SRC, 'src/')}:${i + 1}  ${label}\n    ${raw.trim()}`);
+        bad++;
+      }
+    }
+  });
+}
+
+// A capability src/ does not have, it must not be able to BORROW either.
+// `login` writes a key to disk and `deep` uploads a digest - both real, both
+// necessary, both living in net/. If src/ could import them, this script would
+// print "read-only verified" while the scanner was able to upload the user's
+// repository. A promise that passes its own test and is false is worse than no
+// promise. So: src/ may import only from src/.
+for (const f of files) {
+  const text = readFileSync(f, 'utf8');
+  text.split('\n').forEach((raw, i) => {
+    if (raw.trimStart().startsWith('//')) return;
+    const m = raw.match(/^\s*(?:import|export)[^'"]*from\s+['"]([^'"]+)['"]/)
+           || raw.match(/\bimport\s*\(\s*['"]([^'"]+)['"]/);
+    if (!m) return;
+    const spec = m[1];
+    if (!spec.startsWith('.')) return;                 // node: builtins are covered above
+    if (/^\.\.\/(?!src\/)/.test(spec) || spec.startsWith('../../')) {
+      console.error(`  ${f.replace(SRC, 'src/')}:${i + 1}  reaches outside src/\n    ${raw.trim()}`);
+      bad++;
+    }
+  });
+}
+
+if (bad) {
+  console.error(`\nFAIL — ${bad} capability violation(s). The Launchprep scanner must stay read-only.`);
+  process.exit(1);
+}
+console.log(`read-only verified across ${files.length} source file(s) — no writes, no exec, no network, and nothing imported from outside src/`);

package/src/brand.mjs

@@ -0,0 +1,15 @@
+// The product name lives here and nowhere else.
+//
+// Renaming is a one-line change until the day this is published. After that,
+// the npm package name and the plugin id are claimed by users who installed
+// them, and a rename breaks their setup - so decide the real name before the
+// first public release, not after.
+export const BRAND = {
+  name:     'Launchprep',   // shown to humans
+  slug:     'launchprep',   // npm package, plugin id, slash command
+  tagline:  'readiness scan',
+  email:    'hello@launchprep.dev',   // the address that actually receives
+  api:      'https://api.launchprep.dev',
+};
+
+export const CMD = '/' + BRAND.slug;