blitzstrike 1.0.31 → 1.0.32

package/CHANGELOG.md

@@ -51,6 +51,9 @@ code path, not a slogan.
   master reference of web attack vectors (RCE, SQL, auth, SSRF, XSS, API,
   business logic, race conditions, cloud, supply chain, CI/CD, AI/LLM, Web3,
   XS-leaks, …) for BLITZ attack-surface mapping.
+- **Self-update** (`blitzstrike update` + `check_update` tool) — query the npm
+  registry for the latest version (semver-aware) and refresh the heavy data
+  cache (payloads + templates) in one shot.
 
 ### Changed
 

package/README.md

@@ -117,6 +117,8 @@ blitzstrike serve --mcp       # start MCP server over stdio (default)
 blitzstrike doctor            # health check: runtime + 130-tool catalog + creds
 blitzstrike install           # write MCP config to detected clients (Claude/Cursor/OpenCode)
 blitzstrike install --dry-run # preview the config without writing
+blitzstrike sync-data         # fetch heavy datasets (payloads + templates) on-demand
+blitzstrike update            # check for a newer version + refresh the data cache
 blitzstrike version           # print version
 ```
 
@@ -226,6 +228,7 @@ MCP servers. With no client detected, it prints the snippet for manual paste.
 | `template_lookup(topic)` | Find nuclei detection templates (11.9k YAML signatures). |
 | `list_attack_vectors()` | List the full web attack-vector taxonomy (34 categories, 588 vectors). |
 | `attack_vectors(category)` | Enumerate the vector list for one category (e.g. ssrf, business logic, ai/llm). |
+| `check_update()` | Query the npm registry for the latest blitzstrike version. |
 
 The intelligence layer (WAF signatures, tech/CVE/port correlations, fuzzer
 data, vuln ontology, exploit payloads, nuclei detection templates) is sourced

package/dist/index.js

@@ -14820,11 +14820,11 @@ var require_src = __commonJS(function(exports, module) {
 });
 
 // src/sync.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, readFileSync as readFileSync11, readdirSync as readdirSync5, statSync as statSync3, rmSync as rmSync2 } from "node:fs";
-import { join as join9 } from "node:path";
-import { homedir as homedir4 } from "node:os";
-import { fileURLToPath as fileURLToPath7 } from "node:url";
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, readFileSync as readFileSync10, readdirSync as readdirSync5, statSync as statSync3, rmSync as rmSync2 } from "node:fs";
+import { join as join8 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
+import { spawnSync as spawnSync2 } from "node:child_process";
 function dirExists(p) {
   try {
     return statSync3(p).isDirectory();
@@ -14838,7 +14838,7 @@ function countFiles(dir) {
     const walk = (d) => {
       for (const e of readdirSync5(d, { withFileTypes: true })) {
         if (e.isDirectory())
-          walk(join9(d, e.name));
+          walk(join8(d, e.name));
         else
           n++;
       }
@@ -14851,9 +14851,9 @@ function countFiles(dir) {
 }
 function syncData() {
   if (!dirExists(DATA_ROOT2))
-    mkdirSync3(DATA_ROOT2, { recursive: true });
-  const payloadsPath = join9(DATA_ROOT2, "payloads");
-  const templatesPath = join9(DATA_ROOT2, "templates");
+    mkdirSync2(DATA_ROOT2, { recursive: true });
+  const payloadsPath = join8(DATA_ROOT2, "payloads");
+  const templatesPath = join8(DATA_ROOT2, "templates");
   const hasPayloads = dirExists(payloadsPath) && countFiles(payloadsPath) > 0;
   const hasTemplates = dirExists(templatesPath) && countFiles(templatesPath) > 0;
   if (hasPayloads && hasTemplates) {
@@ -14863,8 +14863,8 @@ function syncData() {
       data_root: DATA_ROOT2
     };
   }
-  const localPayloads = join9(ROOT6, "payloads");
-  const localTemplates = join9(ROOT6, "templates");
+  const localPayloads = join8(ROOT5, "payloads");
+  const localTemplates = join8(ROOT5, "templates");
   let payloadsSynced = false;
   let templatesSynced = false;
   if (!hasPayloads && dirExists(localPayloads)) {
@@ -14875,21 +14875,21 @@ function syncData() {
     copyDir(localTemplates, templatesPath);
     templatesSynced = true;
   }
-  const gitOk = spawnSync3("git", ["--version"]).status === 0;
+  const gitOk = spawnSync2("git", ["--version"]).status === 0;
   if (gitOk && (!dirExists(payloadsPath) || countFiles(payloadsPath) === 0 || !dirExists(templatesPath) || countFiles(templatesPath) === 0)) {
-    const tmp = join9(DATA_ROOT2, ".tmp-clone");
+    const tmp = join8(DATA_ROOT2, ".tmp-clone");
     if (dirExists(tmp))
       rmSync2(tmp, { recursive: true, force: true });
-    const r = spawnSync3("git", ["clone", "--depth", "1", "--filter=blob:none", "--sparse", GITHUB_REPO, tmp], { timeout: 120000 });
+    const r = spawnSync2("git", ["clone", "--depth", "1", "--filter=blob:none", "--sparse", GITHUB_REPO, tmp], { timeout: 120000 });
     if (r.status === 0) {
-      const sparse = spawnSync3("git", ["-C", tmp, "sparse-checkout", "set", "payloads", "templates"], { timeout: 120000 });
+      const sparse = spawnSync2("git", ["-C", tmp, "sparse-checkout", "set", "payloads", "templates"], { timeout: 120000 });
       if (sparse.status === 0) {
         if (!dirExists(payloadsPath) || countFiles(payloadsPath) === 0) {
-          copyDir(join9(tmp, "payloads"), payloadsPath);
+          copyDir(join8(tmp, "payloads"), payloadsPath);
           payloadsSynced = true;
         }
         if (!dirExists(templatesPath) || countFiles(templatesPath) === 0) {
-          copyDir(join9(tmp, "templates"), templatesPath);
+          copyDir(join8(tmp, "templates"), templatesPath);
           templatesSynced = true;
         }
       }
@@ -14903,26 +14903,67 @@ function syncData() {
   };
 }
 function copyDir(src, dst) {
-  const r = spawnSync3("cp", ["-r", src, dst], { timeout: 120000 });
+  const r = spawnSync2("cp", ["-r", src, dst], { timeout: 120000 });
   if (r.status !== 0) {
     manualCopy(src, dst);
   }
 }
 function manualCopy(src, dst) {
-  mkdirSync3(dst, { recursive: true });
+  mkdirSync2(dst, { recursive: true });
   for (const e of readdirSync5(src, { withFileTypes: true })) {
-    const s = join9(src, e.name);
-    const d = join9(dst, e.name);
+    const s = join8(src, e.name);
+    const d = join8(dst, e.name);
     if (e.isDirectory())
       manualCopy(s, d);
     else
-      writeFileSync4(d, readFileSync11(s));
+      writeFileSync3(d, readFileSync10(s));
   }
 }
-var ROOT6, DATA_ROOT2, GITHUB_REPO = "https://github.com/shinthink/blitzstrike.git";
+var ROOT5, DATA_ROOT2, GITHUB_REPO = "https://github.com/shinthink/blitzstrike.git";
 var init_sync = __esm(() => {
-  ROOT6 = join9(fileURLToPath7(new URL(".", import.meta.url)), "..");
-  DATA_ROOT2 = process.env.BLITZSTRIKE_DATA ?? join9(homedir4(), ".blitzstrike", "data");
+  ROOT5 = join8(fileURLToPath6(new URL(".", import.meta.url)), "..");
+  DATA_ROOT2 = process.env.BLITZSTRIKE_DATA ?? join8(homedir3(), ".blitzstrike", "data");
+});
+
+// src/update.ts
+async function checkLatestVersion(timeoutMs = 1e4) {
+  try {
+    const controller = new AbortController;
+    const t = setTimeout(() => controller.abort(), timeoutMs);
+    const res = await fetch("https://registry.npmjs.org/blitzstrike/latest", { signal: controller.signal });
+    clearTimeout(t);
+    if (!res.ok)
+      return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function semverCompare(a, b) {
+  const pa = a.replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = b.replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0;i < 3; i++) {
+    const x = pa[i] ?? 0;
+    const y = pb[i] ?? 0;
+    if (x !== y)
+      return x < y ? -1 : 1;
+  }
+  return 0;
+}
+async function runUpdate(currentVersion) {
+  const latest = await checkLatestVersion();
+  const outdated = latest !== null && semverCompare(currentVersion, latest) < 0;
+  return {
+    current: currentVersion,
+    latest,
+    outdated,
+    update_command: "npm install -g blitzstrike@latest   # or: bun add -g blitzstrike@latest",
+    data_sync: syncData()
+  };
+}
+var init_update = __esm(() => {
+  init_sync();
 });
 
 // node_modules/zod/v3/helpers/util.js
@@ -50833,6 +50874,18 @@ function coverageMatrix() {
 }
 
 // src/server.ts
+init_update();
+import { readFileSync as readFileSync11 } from "node:fs";
+import { join as join9, dirname } from "node:path";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
+var VERSION = (() => {
+  try {
+    const root = join9(dirname(fileURLToPath7(import.meta.url)), "..");
+    return JSON.parse(readFileSync11(join9(root, "package.json"), "utf8")).version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+})();
 function createServer() {
   const server = new McpServer({
     name: "blitzstrike",
@@ -51589,7 +51642,7 @@ function createServer() {
     } catch {
       return { content: [{ type: "text", text: JSON.stringify({ error: "invalid JSON" }) }] };
     }
-    const opts = { title, scope, version: "1.0.23" };
+    const opts = { title, scope, version: VERSION };
     const out = (format ?? "markdown") === "json" ? reportJson(list, opts) : reportMarkdown(list, opts);
     return { content: [{ type: "text", text: out }] };
   });
@@ -51607,6 +51660,14 @@ function createServer() {
   }, async () => {
     return { content: [{ type: "text", text: JSON.stringify(coverageMatrix()) }] };
   });
+  server.registerTool("check_update", {
+    title: "Check for a newer blitzstrike version",
+    description: "UPDATE: query the npm registry for the latest blitzstrike version. Tells a driving agent whether the package or the data cache is stale.",
+    inputSchema: {}
+  }, async () => {
+    const latest = await checkLatestVersion();
+    return { content: [{ type: "text", text: JSON.stringify({ latest, note: "package updates via `npx blitzstrike` (always-latest) or `npm i -g blitzstrike@latest`; heavy data via `blitzstrike sync-data`" }) }] };
+  });
   return server;
 }
 async function serve() {
@@ -51616,14 +51677,14 @@ async function serve() {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync10, existsSync as existsSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join8, dirname } from "node:path";
-import { homedir as homedir3 } from "node:os";
-import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { spawnSync as spawnSync2 } from "node:child_process";
-var ROOT5 = join8(fileURLToPath6(new URL(".", import.meta.url)), "..");
+import { readFileSync as readFileSync12, existsSync as existsSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join10, dirname as dirname2 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { fileURLToPath as fileURLToPath8 } from "node:url";
+import { spawnSync as spawnSync3 } from "node:child_process";
+var ROOT6 = join10(fileURLToPath8(new URL(".", import.meta.url)), "..");
 function which(cmd) {
-  return spawnSync2(`command -v ${cmd}`, { shell: true }).status === 0;
+  return spawnSync3(`command -v ${cmd}`, { shell: true }).status === 0;
 }
 function installedCount() {
   const tools = loadTools();
@@ -51656,7 +51717,7 @@ function runDoctor() {
     detail: fofa ? "set" : "FOFA_EMAIL/FOFA_KEY not set",
     fix: fofa ? undefined : "export FOFA_EMAIL=... && export FOFA_KEY=... (enables fofa_search)"
   });
-  const dataOk = existsSync5(join8(ROOT5, "chains.json")) && existsSync5(join8(ROOT5, "tools-catalog.json"));
+  const dataOk = existsSync5(join10(ROOT6, "chains.json")) && existsSync5(join10(ROOT6, "tools-catalog.json"));
   issues.push({
     name: "Data layers (chains + tools-catalog)",
     status: dataOk ? "ok" : "fail",
@@ -51684,73 +51745,73 @@ BlitzStrike — ${verdict}`);
 function resolveCommand() {
   if (which("blitzstrike"))
     return { command: "blitzstrike", args: ["serve", "--mcp"] };
-  const src = join8(ROOT5, "src", "index.ts");
+  const src = join10(ROOT6, "src", "index.ts");
   if (which("bun") && existsSync5(src))
     return { command: "bun", args: ["run", src, "serve", "--mcp"] };
   if (which("npx"))
     return { command: "npx", args: ["-y", "blitzstrike", "serve", "--mcp"] };
   if (which("bunx"))
     return { command: "bunx", args: ["blitzstrike", "serve", "--mcp"] };
-  const dist = join8(ROOT5, "dist", "index.js");
+  const dist = join10(ROOT6, "dist", "index.js");
   if (existsSync5(dist))
     return { command: "bun", args: [dist, "serve", "--mcp"] };
   return { command: "npx", args: ["-y", "blitzstrike", "serve", "--mcp"] };
 }
 function readJson(p) {
   try {
-    return JSON.parse(readFileSync10(p, "utf8"));
+    return JSON.parse(readFileSync12(p, "utf8"));
   } catch {
     return null;
   }
 }
 function jsonMcpServersWrite(p) {
   return (command, args) => {
-    const dir = dirname(p);
+    const dir = dirname2(p);
     if (!existsSync5(dir))
-      mkdirSync2(dir, { recursive: true });
+      mkdirSync3(dir, { recursive: true });
     const existing = readJson(p) ?? {};
     existing.mcpServers = {
       ...existing.mcpServers ?? {},
       blitzstrike: { command, args }
     };
-    writeFileSync3(p, JSON.stringify(existing, null, 2));
+    writeFileSync4(p, JSON.stringify(existing, null, 2));
   };
 }
 function opencodeWrite(p) {
   return (_command, _args) => {
-    const dir = dirname(p);
+    const dir = dirname2(p);
     if (!existsSync5(dir))
-      mkdirSync2(dir, { recursive: true });
+      mkdirSync3(dir, { recursive: true });
     const existing = readJson(p) ?? {};
     existing.mcp = {
       ...existing.mcp ?? {},
       blitzstrike: { type: "local", command: ["npx", "-y", "blitzstrike", "serve", "--mcp"], enabled: true }
     };
-    writeFileSync3(p, JSON.stringify(existing, null, 2));
+    writeFileSync4(p, JSON.stringify(existing, null, 2));
     copyOpenCodeAgents();
   };
 }
 function copyOpenCodeAgents() {
-  const srcDir = join8(ROOT5, "opencode-agents");
-  const dstDir = join8(homedir3(), ".config", "opencode", "agents");
+  const srcDir = join10(ROOT6, "opencode-agents");
+  const dstDir = join10(homedir4(), ".config", "opencode", "agents");
   if (!existsSync5(srcDir))
     return;
   if (!existsSync5(dstDir))
-    mkdirSync2(dstDir, { recursive: true });
+    mkdirSync3(dstDir, { recursive: true });
   for (const f of ["Blitz Strike.md", "Blitz.md", "Eagle Eye.md", "Strike.md"]) {
-    const src = join8(srcDir, f);
-    const dst = join8(dstDir, f);
+    const src = join10(srcDir, f);
+    const dst = join10(dstDir, f);
     if (existsSync5(src)) {
-      writeFileSync3(dst, readFileSync10(src, "utf8"));
+      writeFileSync4(dst, readFileSync12(src, "utf8"));
     }
   }
 }
 function codexWrite(p) {
   return (command, args) => {
-    const dir = dirname(p);
+    const dir = dirname2(p);
     if (!existsSync5(dir))
-      mkdirSync2(dir, { recursive: true });
-    let existing = existsSync5(p) ? readFileSync10(p, "utf8") : "";
+      mkdirSync3(dir, { recursive: true });
+    let existing = existsSync5(p) ? readFileSync12(p, "utf8") : "";
     if (!existing.trimEnd().endsWith(`
 `))
       existing += `
@@ -51761,15 +51822,15 @@ function codexWrite(p) {
 command = "${command}"
 args = ${JSON.stringify(args)}
 `;
-    writeFileSync3(p, existing);
+    writeFileSync4(p, existing);
   };
 }
 function hermesWrite(p) {
   return (command, args) => {
-    const dir = dirname(p);
+    const dir = dirname2(p);
     if (!existsSync5(dir))
-      mkdirSync2(dir, { recursive: true });
-    let existing = existsSync5(p) ? readFileSync10(p, "utf8") : "";
+      mkdirSync3(dir, { recursive: true });
+    let existing = existsSync5(p) ? readFileSync12(p, "utf8") : "";
     existing = existing.replace(/^  blitzstrike:\n(?:    .*\n?)*/m, "");
     if (!existing.trimEnd().endsWith(`
 `))
@@ -51790,80 +51851,80 @@ mcp_servers:
     args: ${JSON.stringify(args)}
 `;
     }
-    writeFileSync3(p, existing);
+    writeFileSync4(p, existing);
   };
 }
 function detectAgents() {
-  const home = homedir3();
+  const home = homedir4();
   const agents = [];
-  const claudeJson = join8(home, ".claude.json");
+  const claudeJson = join10(home, ".claude.json");
   agents.push({
     name: "Claude Code",
     detectPath: claudeJson,
     installed: () => existsSync5(claudeJson) || which("claude"),
     write: jsonMcpServersWrite(claudeJson)
   });
-  const claudeDesktop = join8(home, ".config", "Claude", "claude_desktop_config.json");
+  const claudeDesktop = join10(home, ".config", "Claude", "claude_desktop_config.json");
   agents.push({
     name: "Claude Desktop",
     detectPath: claudeDesktop,
     installed: () => existsSync5(claudeDesktop),
     write: jsonMcpServersWrite(claudeDesktop)
   });
-  const cursor = join8(home, ".cursor", "mcp.json");
+  const cursor = join10(home, ".cursor", "mcp.json");
   agents.push({
     name: "Cursor",
     detectPath: cursor,
-    installed: () => existsSync5(join8(home, ".cursor")) || which("cursor"),
+    installed: () => existsSync5(join10(home, ".cursor")) || which("cursor"),
     write: jsonMcpServersWrite(cursor)
   });
-  const opencode = join8(home, ".config", "opencode", "opencode.jsonc");
+  const opencode = join10(home, ".config", "opencode", "opencode.jsonc");
   agents.push({
     name: "OpenCode",
     detectPath: opencode,
-    installed: () => existsSync5(join8(home, ".config", "opencode")) || which("opencode"),
+    installed: () => existsSync5(join10(home, ".config", "opencode")) || which("opencode"),
     write: opencodeWrite(opencode)
   });
-  const codex = join8(home, ".codex", "config.toml");
+  const codex = join10(home, ".codex", "config.toml");
   agents.push({
     name: "Codex",
     detectPath: codex,
-    installed: () => existsSync5(join8(home, ".codex")) || which("codex"),
+    installed: () => existsSync5(join10(home, ".codex")) || which("codex"),
     write: codexWrite(codex)
   });
-  const hermes = join8(home, ".hermes", "config.yaml");
+  const hermes = join10(home, ".hermes", "config.yaml");
   agents.push({
     name: "Hermes",
     detectPath: hermes,
-    installed: () => existsSync5(join8(home, ".hermes")) || which("hermes"),
+    installed: () => existsSync5(join10(home, ".hermes")) || which("hermes"),
     write: hermesWrite(hermes)
   });
-  const gemini = join8(home, ".gemini", "settings.json");
+  const gemini = join10(home, ".gemini", "settings.json");
   agents.push({
     name: "Gemini CLI",
     detectPath: gemini,
-    installed: () => existsSync5(join8(home, ".gemini")) || which("gemini"),
+    installed: () => existsSync5(join10(home, ".gemini")) || which("gemini"),
     write: jsonMcpServersWrite(gemini)
   });
-  const windsurf = join8(home, ".codeium", "windsurf", "mcp_config.json");
+  const windsurf = join10(home, ".codeium", "windsurf", "mcp_config.json");
   agents.push({
     name: "Windsurf",
     detectPath: windsurf,
-    installed: () => existsSync5(join8(home, ".codeium")) || which("windsurf"),
+    installed: () => existsSync5(join10(home, ".codeium")) || which("windsurf"),
     write: jsonMcpServersWrite(windsurf)
   });
-  const copilot = join8(home, ".copilot", "mcp.json");
+  const copilot = join10(home, ".copilot", "mcp.json");
   agents.push({
     name: "Copilot",
     detectPath: copilot,
-    installed: () => existsSync5(join8(home, ".copilot")),
+    installed: () => existsSync5(join10(home, ".copilot")),
     write: jsonMcpServersWrite(copilot)
   });
-  const cline = join8(home, ".cline", "mcp_settings.json");
+  const cline = join10(home, ".cline", "mcp_settings.json");
   agents.push({
     name: "Cline",
     detectPath: cline,
-    installed: () => existsSync5(join8(home, ".cline")),
+    installed: () => existsSync5(join10(home, ".cline")),
     write: jsonMcpServersWrite(cline)
   });
   return agents;
@@ -51907,29 +51968,31 @@ Registered with ${ok}/${installed.length} agent(s).`);
 }
 
 // src/index.ts
-import { readFileSync as readFileSync12, existsSync as existsSync6 } from "node:fs";
-import { join as join10 } from "node:path";
-import { fileURLToPath as fileURLToPath8 } from "node:url";
-var ROOT7 = join10(fileURLToPath8(new URL(".", import.meta.url)), "..");
+import { readFileSync as readFileSync13, existsSync as existsSync6 } from "node:fs";
+import { join as join11 } from "node:path";
+import { fileURLToPath as fileURLToPath9 } from "node:url";
+var ROOT7 = join11(fileURLToPath9(new URL(".", import.meta.url)), "..");
 function readVersion() {
   try {
-    const p = join10(ROOT7, "package.json");
+    const p = join11(ROOT7, "package.json");
     if (existsSync6(p))
-      return JSON.parse(readFileSync12(p, "utf8")).version ?? "1.0.0";
+      return JSON.parse(readFileSync13(p, "utf8")).version ?? "1.0.0";
   } catch {}
   return "1.0.0";
 }
-var VERSION = readVersion();
+var VERSION2 = readVersion();
 function usage() {
-  return `BlitzStrike ${VERSION} — MCP security-audit toolbelt
+  return `BlitzStrike ${VERSION2} — MCP security-audit toolbelt
 
 Usage:
   blitzstrike serve --mcp       Start the MCP server over stdio (default transport)
   blitzstrike doctor            Environment health check (runtime + tools + creds)
   blitzstrike install           Write MCP client config to detected clients
   blitzstrike install --dry-run Print the config without writing
-  blitzstrike version           Print version
-  blitzstrike --help            This help`;
+  blitzstrike sync-data        Fetch heavy datasets (payloads + templates) on-demand
+  blitzstrike update           Check for a newer version + refresh the data cache
+  blitzstrike version          Print version
+  blitzstrike --help           This help`;
 }
 async function main() {
   const args = process.argv.slice(2);
@@ -51938,7 +52001,7 @@ async function main() {
     return;
   }
   if (args[0] === "version" || args[0] === "--version" || args[0] === "-v") {
-    console.log(`blitzstrike ${VERSION}`);
+    console.log(`blitzstrike ${VERSION2}`);
     return;
   }
   if (args[0] === "doctor") {
@@ -51958,6 +52021,22 @@ async function main() {
     console.log(`  templates: ${r.templates.files} files ${r.templates.synced ? "(synced)" : "(already present)"}`);
     return;
   }
+  if (args[0] === "update") {
+    await Promise.resolve().then(() => init_update());
+    const r = await runUpdate(VERSION2);
+    console.log("Blitz Strike self-update");
+    console.log(`  current: ${r.current}`);
+    console.log(`  latest:  ${r.latest ?? "unknown (registry unreachable)"}`);
+    if (r.outdated) {
+      console.log(`  status:  OUTDATED — update with: ${r.update_command}`);
+    } else if (r.latest === null) {
+      console.log(`  status:  could not reach npm registry`);
+    } else {
+      console.log(`  status:  up to date`);
+    }
+    console.log(`  data:    payloads ${r.data_sync.payloads.files} files, templates ${r.data_sync.templates.files} files ${r.data_sync.payloads.synced ? "(refreshed)" : ""}`);
+    return;
+  }
   if (args[0] === "serve") {
     await serve();
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blitzstrike",
-  "version": "1.0.31",
+  "version": "1.0.32",
   "description": "Blitz Strike — a universal MCP security-audit toolbelt. BLITZ sweeps the attack surface, EAGLE-EYE traces source-to-sink, STRIKE verifies live. 57 attack chains, 130-tool catalog, intelligence data layer. One server, every agent.",
   "type": "module",
   "bin": {