@jikida/init 0.2.1 → 0.4.0

package/bin/init.js

@@ -12,7 +12,7 @@
  * Everything is idempotent: re-running skips already-done steps.
  */
 
-import { readFileSync, existsSync, writeFileSync, appendFileSync, mkdirSync } from 'node:fs';
+import { readFileSync, existsSync, writeFileSync, appendFileSync, mkdirSync, readdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execSync, spawnSync } from 'node:child_process';
@@ -117,13 +117,42 @@ function installSkill() {
   // Master skill (full body) + one thin bootstrap per assistant, so "install into
   // every editor you already use" actually holds — Cursor, Windsurf, Cline,
   // Copilot, Aider, Continue, Claude, Gemini, plus the generic AGENTS.md.
+  // The Continue.dev config is YAML with a `rules:` block, not free prose — wrap
+  // the bootstrap so it drops in as a valid rule instead of breaking the parser.
+  const continueYaml =
+    'name: Jikida security\n' +
+    'version: 0.0.1\n' +
+    'rules:\n' +
+    '  - >\n' +
+    bootstrap.split('\n').map((l) => '    ' + l).join('\n') + '\n';
+
+  // A Claude Code slash command: `/jikida-scan` in the editor kicks off the
+  // guided repo scan without the user remembering the phrasing.
+  const scanCommand =
+    '---\n' +
+    'description: Scan this repo for leaked secrets, exposed rules, and vulnerabilities (Jikida)\n' +
+    '---\n\n' +
+    'Read `.claude/skills/jikida/SKILL.md`, then run a full security pass on this\n' +
+    'repository: committed secrets (.env, serviceAccountKey.json, *.pem, API keys),\n' +
+    'open Supabase/Firebase rules, missing auth checks, injection, and out-of-date\n' +
+    'dependencies with known CVEs. Walk the 25-category catalog. Report findings\n' +
+    'worst-first with a one-line fix each, and apply fixes at the lowest safe\n' +
+    'intervention level. Ask before anything destructive. Record what you find in\n' +
+    '`memory-security.md`.\n';
+
+  // `managed: true` = a Jikida-owned file we fully (re)write on every run so
+  // updates land and re-running never appends a duplicate (SKILL.md, our own
+  // .mdc/command/continue files). The rest are shared assistant files we only
+  // append-if-missing so we never clobber a user's own rules.
   const targets = [
-    [join(cwd, '.claude', 'skills', 'jikida', 'SKILL.md'), body],
+    [join(cwd, '.claude', 'skills', 'jikida', 'SKILL.md'), body, true],
+    [join(cwd, '.claude', 'commands', 'jikida-scan.md'), scanCommand, true],
+    [join(cwd, '.cursor', 'rules', 'jikida.mdc'), mdc, true],
+    [join(cwd, '.continue', 'config.yaml'), continueYaml, true],
     [join(cwd, 'AGENTS.md'), bootstrap],
     [join(cwd, 'CLAUDE.md'), bootstrap],
     [join(cwd, 'GEMINI.md'), bootstrap],
     [join(cwd, '.cursorrules'), bootstrap],
-    [join(cwd, '.cursor', 'rules', 'jikida.mdc'), mdc],
     [join(cwd, '.windsurfrules'), bootstrap],
     [join(cwd, '.clinerules'), bootstrap],
     [join(cwd, '.aider.conf.yml'), bootstrap],
@@ -134,14 +163,14 @@ function installSkill() {
   log('  ----------------------------');
   const MARK = 'Jikida security skill';
   let wrote = 0, skipped = 0;
-  for (const [target, content] of targets) {
+  for (const [target, content, managed] of targets) {
     const rel = target.replace(cwd + '/', '');
     try {
       mkdirSync(dirname(target), { recursive: true });
-      // The master SKILL.md is always (re)written so updates land. The per-
-      // assistant files are APPEND-if-present, skip-if-already-ours — never clobber
-      // a user's existing rules file, never double-add.
-      if (target.endsWith('SKILL.md')) {
+      // Managed (Jikida-owned) files are always (re)written so updates land and
+      // re-runs never duplicate. Shared assistant files are APPEND-if-present,
+      // skip-if-already-ours — never clobber a user's own rules, never double-add.
+      if (managed) {
         writeFileSync(target, content);
         done(rel); wrote++;
       } else if (!existsSync(target)) {
@@ -157,11 +186,67 @@ function installSkill() {
       warn(`Could not write ${rel}: ${e.message}`);
     }
   }
+  // Copy the bundled checklists (pre-deploy, supabase/firebase) next to the
+  // master skill so the assistant can walk them before a launch.
+  try {
+    const clSrc = join(here, '..', 'skill', 'checklists');
+    if (existsSync(clSrc)) {
+      const dstDir = join(cwd, '.claude', 'skills', 'jikida', 'checklists');
+      mkdirSync(dstDir, { recursive: true });
+      for (const f of readdirSync(clSrc)) {
+        writeFileSync(join(dstDir, f), readFileSync(join(clSrc, f), 'utf8'));
+      }
+      done('.claude/skills/jikida/checklists/'); wrote++;
+    }
+  } catch (e) { warn(`Could not copy checklists: ${e.message}`); }
+
+  // Harden .gitignore: a security skill install should also stop the classic
+  // leaks it scans for from ever being committed. Append only the lines that are
+  // missing, under one clearly-marked block — never duplicate, never reorder the
+  // user's file.
+  try {
+    const giPath = join(cwd, '.gitignore');
+    const current = existsSync(giPath) ? readFileSync(giPath, 'utf8') : '';
+    const wanted = [
+      '.env', '.env.*', '!.env.example',
+      '*.pem', '*.key', '*.p8', '*.p12', '*.keystore',
+      'serviceAccountKey.json', '*-firebase-adminsdk-*.json', 'google-services.json',
+      '*.mobileprovision', 'secrets.*', '.jikida/',
+    ];
+    const missing = wanted.filter((line) => {
+      const re = new RegExp('^' + line.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\s*$', 'm');
+      return !re.test(current);
+    });
+    if (missing.length) {
+      const block = (current && !current.endsWith('\n') ? '\n' : '')
+        + '\n# Jikida security — do not commit secrets\n' + missing.join('\n') + '\n';
+      appendFileSync(giPath, block);
+      done(`.gitignore (+${missing.length} security entr${missing.length === 1 ? 'y' : 'ies'})`); wrote++;
+    }
+  } catch (e) { warn(`Could not update .gitignore: ${e.message}`); }
+
+  // A persistent findings log the assistant appends to across sessions, so a
+  // scan's results and the "still to fix" list survive context resets.
+  try {
+    const memPath = join(cwd, 'memory-security.md');
+    if (!existsSync(memPath)) {
+      writeFileSync(memPath,
+        '# Security memory (Jikida)\n\n' +
+        'The assistant appends findings and their status here as it scans and fixes.\n' +
+        'Read this at the start of a security pass so nothing is re-flagged or lost.\n\n' +
+        '## Open findings\n\n_none yet — run `/jikida-scan` or ask your AI to scan the repo._\n\n' +
+        '## Fixed\n\n');
+      done('memory-security.md'); wrote++;
+    }
+  } catch (e) { warn(`Could not write memory-security.md: ${e.message}`); }
+
   if (wrote > 0 || skipped > 0) {
     log('');
     if (skipped > 0) { log(`  ${skipped} file(s) already had the skill — left untouched.`); }
-    log('  Done. Your AI editors now know Jikida — restart them, then ask them to');
-    log('  "add Jikida security to this app" or "scan my repo for leaked secrets".');
+    log('  Done. Your AI editors now know Jikida. Restart them, then:');
+    log('');
+    log('  ⚡ Run /jikida-scan in Claude Code — or ask any AI to');
+    log('     "scan my repo for leaked secrets and open rules".');
     log('');
   }
   process.exit((wrote > 0 || skipped > 0) ? 0 : 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jikida/init",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "One command to install a production Web Application Firewall. Detects Node (Next.js / Express / Fastify), PHP (Laravel / Symfony), and Python (Django / FastAPI / Flask), installs the right Jikida SDK, wires the middleware, writes JIKIDA_TOKEN to .env. $0 to start. Fails open. Playground + MCP for Claude Code / Cursor / Windsurf included.",
   "type": "module",
   "bin": {

package/skill/SKILL.md

@@ -359,3 +359,10 @@ Default to the lowest level that fixes the finding. Anything destructive or irre
 
 - **Score** — start at 100; subtract Critical 20 / High 10 / Medium 5 / Low 2, floored at 0. Grade: 90+ A, 70+ B, 50+ C, below 50 F. Non-applicable categories drop out and their weight redistributes.
 - **Memory** — persist the score, accepted risks and custom rules across scans (in the app, or a local `memory-security.md` for the CLI). Re-runs show the trend and never re-flag an accepted risk. User preferences always win over a generic recommendation.
+
+## Checklists
+
+Concrete runbooks bundled with this skill — walk them before a launch:
+
+- `checklists/pre-deploy.md` — the full pre-ship checklist across every category.
+- `checklists/supabase-firebase.md` — the #1 vibe-coder leak (open RLS / test-mode rules); check before any launch.

package/skill/checklists/pre-deploy.md

@@ -0,0 +1,46 @@
+# Pre-deploy security checklist
+
+Run this before every ship, merge, or "make the repo public". Each item maps to a Jikida check you can run with `npx @jikida/scan` or the MCP tools. Fix at the lowest safe level; ask before anything destructive.
+
+## Secrets
+- [ ] No API keys, tokens, or passwords committed (grep the diff; run a repo scan).
+- [ ] `.env`, `serviceAccountKey.json`, `*.pem`, `*.db` are in `.gitignore` and NOT tracked.
+- [ ] No `service_role`, admin, or private key used in client-side code or shipped in the bundle.
+- [ ] Rotate anything that was ever committed — removing it from HEAD is not enough.
+
+## Database
+- [ ] Supabase RLS is ON for every table holding user data (default-deny, then explicit policies).
+- [ ] Firebase rules are not `allow read, write: if true` (test mode).
+- [ ] No endpoint trusts a client-supplied `userId` / `ownerId` (IDOR — scope by the session).
+- [ ] PII columns are encrypted or access-controlled.
+
+## Auth & sessions
+- [ ] Session cookies are `HttpOnly`, `Secure`, `SameSite`.
+- [ ] Login and password-reset have brute-force limits.
+- [ ] JWTs verify the signature and reject `alg=none`; tokens have an expiry.
+
+## Transport & headers
+- [ ] HTTPS only; HSTS set.
+- [ ] CSP, X-Content-Type-Options, X-Frame-Options, Referrer-Policy present.
+- [ ] CORS is an explicit origin allowlist — never `*` with credentials.
+
+## Input & injection
+- [ ] All queries are parameterized (no string-built SQL / NoSQL).
+- [ ] File uploads check real type (magic bytes), size, and a safe path.
+- [ ] User input rendered in HTML is escaped; no `dangerouslySetInnerHTML` on untrusted data.
+
+## Dependencies & config
+- [ ] No dependency with a known CVE (run the supply-chain check).
+- [ ] Lockfile committed and up to date.
+- [ ] Debug mode / verbose errors OFF in production.
+- [ ] Rate limiting on auth, write, and expensive endpoints.
+
+## After deploy
+- [ ] Uptime monitor + SSL/domain-expiry watch enabled on the live URL.
+- [ ] A surface pentest run against the deployed site comes back clean or triaged.
+
+Run it all at once:
+
+```
+$ npx @jikida/scan yourdomain.com --repo . --min-score 80
+```

package/skill/checklists/supabase-firebase.md

@@ -0,0 +1,38 @@
+# Supabase & Firebase checklist
+
+The single most common way an AI-built app leaks its whole database. Check this before any launch.
+
+## Supabase
+- [ ] **RLS is enabled on every table with user data.** A table with RLS off is world-readable through the anon key.
+  ```sql
+  -- 🔴 CRITICAL — RLS off: anyone with the public anon key reads every row
+  -- 🟢 CORRECT — enable RLS, then add explicit policies
+  ALTER TABLE public.profiles ENABLE ROW LEVEL SECURITY;
+  CREATE POLICY "own rows" ON public.profiles
+    FOR SELECT USING (auth.uid() = user_id);
+  ```
+- [ ] Policies are default-deny — a table with RLS on but no policy returns nothing, which is safe; a permissive `USING (true)` policy is not.
+- [ ] The `service_role` key is used ONLY on the server, never in client code or the bundle.
+- [ ] Storage buckets holding private files are not public.
+- [ ] Postgres functions marked `SECURITY DEFINER` are reviewed — they bypass RLS.
+
+## Firebase
+- [ ] Firestore/RTDB rules are not left in test mode.
+  ```
+  // 🔴 CRITICAL — test mode: the whole database is public read/write
+  match /{document=**} { allow read, write: if true; }
+  // 🟢 CORRECT — require auth and scope to the owner
+  match /users/{uid}/{doc=**} {
+    allow read, write: if request.auth != null && request.auth.uid == uid;
+  }
+  ```
+- [ ] `google-services.json` / `serviceAccountKey.json` is not committed.
+- [ ] Client API keys are restricted (referrer / bundle-id / API restrictions in the Google console) — a client key is public, so the rules are the real gate.
+- [ ] Cloud Functions validate `context.auth` before any privileged action.
+- [ ] Storage rules mirror the database rules — a locked DB with an open bucket still leaks.
+
+Run the automated version:
+
+```
+$ npx @jikida/scan --repo .   # flags open RLS/rules, committed keys, service_role in client
+```