launchprep 0.3.0 → 0.4.0

package/net/consent.mjs

@@ -21,6 +21,11 @@ export async function confirmUpload({ digest, host, assumeYes = false, showFiles
   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`);
+  if (digest.secretsRedacted > 0) {
+    console.log(`  ${C.g}${digest.secretsRedacted} secret${digest.secretsRedacted === 1 ? '' : 's'} masked before sending${C.off} — keys, passwords, tokens and`);
+    console.log(`  the rows of any database dump are replaced on this machine, so their`);
+    console.log(`  values never leave it. Only that they existed, and where, is sent.\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`);

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "launchprep",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Launch readiness checker. Reads your code and tells you what will break before your users find out.",
   "type": "module",
   "bin": {
-    "launchprep": "./bin/launchprep.mjs"
+    "launchprep": "bin/launchprep.mjs"
   },
   "files": [
     "src",
@@ -17,7 +17,7 @@
   "scripts": {
     "verify": "node scripts/verify-readonly.mjs",
     "pretest": "node scripts/verify-readonly.mjs",
-    "test": "node test/run.mjs && node test/gate.mjs",
+    "test": "node test/run.mjs && node test/gate.mjs && node test/redact.mjs",
     "prepack": "node scripts/prepare-publish.mjs",
     "postpack": "node scripts/restore-after-publish.mjs"
   },

package/src/digest.mjs

@@ -1,3 +1,5 @@
+import { redact } from './redact.mjs';
+
 // Build the block of code the model reads.
 //
 // This is the single most expensive decision in the product. Every token here
@@ -128,9 +130,15 @@ export function buildDigest(repo, { maxTokens = 150_000, profile = {} } = {}) {
   const omitted = [];
   const spentByKind = {};
   let tokens = 0;
+  let secretsRedacted = 0;
 
   const take = (f, respectShare) => {
-    let body = f.text;
+    // Scrub secret values on this machine, before the file can enter the
+    // payload. A masked secret never leaves the user's disk. Done here rather
+    // than at read time so the free scan — which reads the same files but sends
+    // nothing — pays nothing for it.
+    const scrubbed = redact(f.text, f.path);
+    let body = scrubbed.text;
     let truncated = false;
     if (body.length > MAX_FILE_CHARS) { body = body.slice(0, MAX_FILE_CHARS); truncated = true; }
     const block = `\n──── ${f.path}${truncated ? '  [truncated]' : ''}\n${body}\n`;
@@ -144,6 +152,7 @@ export function buildDigest(repo, { maxTokens = 150_000, profile = {} } = {}) {
     included.push({ path: f.path, kind: f.kind, tokens: cost });
     spentByKind[f.kind] = (spentByKind[f.kind] || 0) + cost;
     tokens += cost;
+    secretsRedacted += scrubbed.count;
     return true;
   };
 
@@ -157,6 +166,9 @@ export function buildDigest(repo, { maxTokens = 150_000, profile = {} } = {}) {
     tokens,
     included,
     omitted,
+    // How many secret values were masked before anything left the machine.
+    // Surfaced on the consent screen so the promise is visible, not just made.
+    secretsRedacted,
     // what the model must be told it cannot see, or it will reason as though
     // the absence of an ownership check is proof there isn't one
     coverage: {

package/src/redact.mjs

@@ -0,0 +1,127 @@
+// Strip secret VALUES out of a file before it is ever put in the upload digest.
+//
+// The deep scan sends a digest of the user's code to our server and on to
+// Anthropic. The privacy page promises credentials are never transmitted, and
+// until this module existed that promise was false: a backup.sql full of card
+// numbers, a docker-compose.yml with a plaintext password, or a key hardcoded
+// in source went up verbatim. Only .env was excluded.
+//
+// This runs in the CLI, on the user's machine, BEFORE anything leaves it — so a
+// masked secret never travels at all, not even to us. That is the only correct
+// place for it; redacting server-side would mean the secret already left.
+//
+// The rule of thumb is the inverse of the scanner's. The scanner must not cry
+// wolf, so it needs evidence before it fires. Redaction is the opposite: a
+// masked non-secret costs a little context, a leaked real secret is the whole
+// failure. So this leans aggressive on things SHAPED like secrets, and only
+// holds back where masking would destroy code the scan genuinely needs — a
+// reference like `process.env.STRIPE_KEY` is good code, not a leak, and stays.
+//
+// What the tier-2 rules ask about — authorization, tenancy, deletion, spend —
+// is never answered by the literal value of a key or a row of customer data, so
+// nothing here reduces what the scan can find.
+
+const TAG = (kind) => `«redacted:${kind}»`;
+
+// 1. PEM private-key blocks — the whole block, header to footer.
+const PEM = /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----/g;
+
+// 2. Credentials embedded in a connection URL: scheme://user:pass@host.
+//    Keep the scheme and host (useful shape), mask only user:pass.
+const CONN = /\b((?:postgres|postgresql|mysql|mysql2|mongodb(?:\+srv)?|redis|rediss|amqp|amqps|mssql|mariadb):\/\/)([^\s:@/]+):([^\s@/]+)@/gi;
+
+// 3. Provider keys by their published shape. pk_ (Stripe publishable) is left
+//    alone on purpose — it is designed to be public, and masking it was one of
+//    the original false positives this whole product learned from.
+const SHAPES = [
+  [/\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{10,}/g,               'stripe-key'],
+  [/\bwhsec_[A-Za-z0-9]{20,}/g,                                 'webhook-secret'],
+  [/\bsk-ant-[A-Za-z0-9_-]{20,}/g,                              'anthropic-key'],
+  [/\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}/g,                        'openai-key'],
+  [/\bAKIA[0-9A-Z]{16}\b/g,                                     'aws-access-key'],
+  [/\bASIA[0-9A-Z]{16}\b/g,                                     'aws-temp-key'],
+  [/\bAIza[0-9A-Za-z_-]{35}\b/g,                                'google-key'],
+  [/\bya29\.[0-9A-Za-z_-]{20,}/g,                               'google-oauth'],
+  [/\bgh[pousr]_[A-Za-z0-9]{36,}/g,                             'github-token'],
+  [/\bglpat-[A-Za-z0-9_-]{20,}/g,                               'gitlab-token'],
+  [/\bxox[baprs]-[A-Za-z0-9-]{10,}/g,                           'slack-token'],
+  [/\bSG\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}/g,             'sendgrid-key'],
+  [/\bre_[A-Za-z0-9_-]{20,}/g,                                  'resend-key'],
+  [/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, 'jwt'],
+];
+
+// 4. A value assigned to a secret-NAMED identifier. This catches the passwords
+//    and tokens that have no distinctive shape. It fires only on string
+//    literals, and holds back where the value is plainly not a secret: an env
+//    reference, a template placeholder, an interpolation, an empty string.
+const SECRET_NAME = /(?:pass(?:word|wd)?|pwd|secret|api[_-]?key|apikey|access[_-]?key|private[_-]?key|client[_-]?secret|auth[_-]?token|token|credentials?|passphrase|dsn|encryption[_-]?key|signing[_-]?key|session[_-]?secret|db[_-]?pass(?:word)?)/i;
+const ASSIGN = new RegExp(
+  '(' + SECRET_NAME.source + '["\'`\\]]?\\s*[:=]\\s*)(["\'`])([^"\'`\\n]{6,}?)\\2',
+  'gi',
+);
+// values that are NOT secrets even though the key name matched
+const NOT_A_SECRET = /^(?:process\.env|import\.meta|os\.environ|ENV\[|Deno\.env|\$\{|\$[A-Z(]|<[A-Za-z%{]|\{\{|%[A-Za-z]|your[_-]|change[_-]?me|placeholder|example|dummy|test[_-]?key|xxx+|\*{3,}|\.{3,}|null|undefined|true|false|none|n\/?a)/i;
+
+// 4b. The same, unquoted: `POSTGRES_PASSWORD: hunter2` / `DB_PASS=hunter2` /
+//     Dockerfile `ENV SECRET hunter2`. This is how .env, YAML, Dockerfiles,
+//     Terraform and .ini files carry secrets, and none of them quote. Applied
+//     ONLY to those config files — in real code a bare `password: foo` is a
+//     variable reference (foo), and masking it would delete a name the scan
+//     wants. The value runs to end of line.
+// colon or equals, spaced or not: `PASSWORD: hunter2` (yaml), `SECRET=hunter2`
+// (.env), `token = "..."` handled by the quoted rule above.
+const ASSIGN_BARE = new RegExp(
+  '(' + SECRET_NAME.source + '["\'`\\]]?\\s*[:=]\\s*)([^\\s"\'`#][^\\n#]*?)(\\s*(?:#.*)?)$',
+  'gim',
+);
+// Dockerfile / shell: `ENV DB_PASSWORD hunter2`, `ARG API_TOKEN=hunter2`. The
+// secret word is a substring of the identifier, and the value is one token.
+const DOCKER_ENV = new RegExp(
+  '\\b(ENV|ARG|export)\\s+([A-Za-z0-9_]*' + SECRET_NAME.source + '[A-Za-z0-9_]*[\\s=]+)(["\']?)([^\\s"\']+)\\3',
+  'gi',
+);
+const CONFIGISH = /(^|\/)(\.env|.*\.env|.*\.ya?ml|.*\.tf|.*\.tfvars|.*\.toml|.*\.ini|.*\.conf|.*\.properties|Dockerfile[^/]*|.*\.dockerfile)$/i;
+
+// 5. Bulk data in a SQL dump. The schema the scan needs comes from CREATE TABLE
+//    and ALTER; the rows do not, and the rows are where the customer PII and any
+//    secret literals in a dump actually live.
+const SQL_INSERT = /(\bINSERT\s+INTO\s+[^\n(]+?)(\([^)]*\)\s*)?\bVALUES\b[\s\S]*?;/gi;
+const SQL_COPY = /(\bCOPY\s+[^\n]+?FROM\s+stdin\s*;)[\s\S]*?\n\\\.$/gim;
+
+export function redact(text, path = '') {
+  if (!text) return { text, count: 0 };
+  let count = 0;
+  const bump = (n = 1) => { count += n; };
+
+  let out = text.replace(PEM, () => (bump(), TAG('private-key')));
+
+  out = out.replace(CONN, (_, scheme) => (bump(), `${scheme}${TAG('credentials')}@`));
+
+  for (const [re, kind] of SHAPES) {
+    out = out.replace(re, () => (bump(), TAG(kind)));
+  }
+
+  out = out.replace(ASSIGN, (m, head, q, val) => {
+    if (NOT_A_SECRET.test(val)) return m;
+    bump();
+    return `${head}${q}${TAG('secret')}${q}`;
+  });
+
+  if (CONFIGISH.test(path)) {
+    out = out.replace(ASSIGN_BARE, (m, head, val, trail) => {
+      if (NOT_A_SECRET.test(val)) return m;
+      bump();
+      return `${head}${TAG('secret')}${trail}`;
+    });
+    out = out.replace(DOCKER_ENV, (m, kw, name, q, val) => {
+      if (NOT_A_SECRET.test(val)) return m;
+      bump();
+      return `${kw} ${name}${q}${TAG('secret')}${q}`;
+    });
+  }
+
+  out = out.replace(SQL_INSERT, (m, head) => (bump(), `${head}VALUES ${TAG('rows')};`));
+  out = out.replace(SQL_COPY, (_, head) => (bump(), `${head} ${TAG('rows')}\n\\.`));
+
+  return { text: out, count };
+}