@node9/proxy 1.7.1 → 1.8.2

package/dist/cli.mjs

@@ -250,6 +250,70 @@ import fs2 from "fs";
 import path2 from "path";
 import os2 from "os";
 import crypto from "crypto";
+function validateShieldDefinition(raw, filePath) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    process.stderr.write(`[node9] Shield file is not an object: ${filePath}
+`);
+    return null;
+  }
+  const r = raw;
+  if (typeof r.name !== "string" || !r.name) {
+    process.stderr.write(`[node9] Shield file missing 'name': ${filePath}
+`);
+    return null;
+  }
+  if (typeof r.description !== "string") {
+    process.stderr.write(`[node9] Shield file missing 'description': ${filePath}
+`);
+    return null;
+  }
+  if (!Array.isArray(r.aliases)) {
+    process.stderr.write(`[node9] Shield file missing 'aliases' array: ${filePath}
+`);
+    return null;
+  }
+  if (!Array.isArray(r.smartRules)) {
+    process.stderr.write(`[node9] Shield file missing 'smartRules' array: ${filePath}
+`);
+    return null;
+  }
+  if (!Array.isArray(r.dangerousWords)) {
+    process.stderr.write(`[node9] Shield file missing 'dangerousWords' array: ${filePath}
+`);
+    return null;
+  }
+  return r;
+}
+function loadShieldsFromDir(dir, label) {
+  const result = {};
+  let entries;
+  try {
+    entries = fs2.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  } catch (err2) {
+    if (err2.code !== "ENOENT") {
+      process.stderr.write(`[node9] Could not read ${label} shields dir ${dir}: ${String(err2)}
+`);
+    }
+    return result;
+  }
+  for (const file of entries) {
+    const filePath = path2.join(dir, file);
+    try {
+      const raw = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+      const shield = validateShieldDefinition(raw, filePath);
+      if (shield) result[shield.name] = shield;
+    } catch (err2) {
+      process.stderr.write(`[node9] Failed to load ${label} shield ${file}: ${String(err2)}
+`);
+    }
+  }
+  return result;
+}
+function buildSHIELDS() {
+  const builtins = loadShieldsFromDir(BUILTIN_DIR, "builtin");
+  const userShields = loadShieldsFromDir(USER_SHIELDS_DIR, "user");
+  return { ...builtins, ...userShields };
+}
 function resolveShieldName(input) {
   const lower = input.toLowerCase();
   if (SHIELDS[lower]) return lower;
@@ -356,255 +420,30 @@ function resolveShieldRule(shieldName, identifier) {
   }
   return null;
 }
-var SHIELDS, SHIELDS_STATE_FILE;
+function installShield(name, shieldJson) {
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    throw new Error(
+      `Invalid shield name '${name}': only alphanumeric characters, hyphens, and underscores are allowed`
+    );
+  }
+  const shield = validateShieldDefinition(shieldJson, `<downloaded:${name}>`);
+  if (!shield) throw new Error(`Downloaded shield '${name}' failed validation`);
+  if (shield.name !== name) {
+    throw new Error(`Shield name mismatch: file declares '${shield.name}' but expected '${name}'`);
+  }
+  fs2.mkdirSync(USER_SHIELDS_DIR, { recursive: true });
+  const filePath = path2.join(USER_SHIELDS_DIR, `${name}.json`);
+  const tmp = `${filePath}.${crypto.randomBytes(6).toString("hex")}.tmp`;
+  fs2.writeFileSync(tmp, JSON.stringify(shieldJson, null, 2), { mode: 384 });
+  fs2.renameSync(tmp, filePath);
+}
+var BUILTIN_DIR, USER_SHIELDS_DIR, SHIELDS, SHIELDS_STATE_FILE;
 var init_shields = __esm({
   "src/shields.ts"() {
     "use strict";
-    SHIELDS = {
-      postgres: {
-        name: "postgres",
-        description: "Protects PostgreSQL databases from destructive AI operations",
-        aliases: ["pg", "postgresql"],
-        smartRules: [
-          {
-            name: "shield:postgres:block-drop-table",
-            tool: "*",
-            conditions: [{ field: "sql", op: "matches", value: "DROP\\s+TABLE", flags: "i" }],
-            verdict: "block",
-            reason: "DROP TABLE is irreversible \u2014 blocked by Postgres shield"
-          },
-          {
-            name: "shield:postgres:block-truncate",
-            tool: "*",
-            conditions: [{ field: "sql", op: "matches", value: "TRUNCATE\\s+TABLE", flags: "i" }],
-            verdict: "block",
-            reason: "TRUNCATE is irreversible \u2014 blocked by Postgres shield"
-          },
-          {
-            name: "shield:postgres:block-drop-column",
-            tool: "*",
-            conditions: [
-              { field: "sql", op: "matches", value: "ALTER\\s+TABLE.*DROP\\s+COLUMN", flags: "i" }
-            ],
-            verdict: "block",
-            reason: "DROP COLUMN is irreversible \u2014 blocked by Postgres shield"
-          },
-          {
-            name: "shield:postgres:review-grant-revoke",
-            tool: "*",
-            conditions: [{ field: "sql", op: "matches", value: "\\b(GRANT|REVOKE)\\b", flags: "i" }],
-            verdict: "review",
-            reason: "Permission changes require human approval (Postgres shield)"
-          }
-        ],
-        dangerousWords: ["dropdb", "pg_dropcluster"]
-      },
-      github: {
-        name: "github",
-        description: "Protects GitHub repositories from destructive AI operations",
-        aliases: ["git"],
-        smartRules: [
-          {
-            // Note: git branch -d/-D is already caught by the built-in review-git-destructive rule.
-            // This rule adds coverage for `git push --delete` which the built-in does not match.
-            name: "shield:github:review-delete-branch-remote",
-            tool: "bash",
-            conditions: [
-              {
-                field: "command",
-                op: "matches",
-                value: "git\\s+push\\s+.*--delete",
-                flags: "i"
-              }
-            ],
-            verdict: "review",
-            reason: "Remote branch deletion requires human approval (GitHub shield)"
-          },
-          {
-            name: "shield:github:block-delete-repo",
-            tool: "*",
-            conditions: [
-              { field: "command", op: "matches", value: "gh\\s+repo\\s+delete", flags: "i" }
-            ],
-            verdict: "block",
-            reason: "Repository deletion is irreversible \u2014 blocked by GitHub shield"
-          }
-        ],
-        dangerousWords: []
-      },
-      aws: {
-        name: "aws",
-        description: "Protects AWS infrastructure from destructive AI operations",
-        aliases: ["amazon"],
-        smartRules: [
-          {
-            name: "shield:aws:block-delete-s3-bucket",
-            tool: "*",
-            conditions: [
-              {
-                field: "command",
-                op: "matches",
-                value: "aws\\s+s3.*rb\\s|aws\\s+s3api\\s+delete-bucket",
-                flags: "i"
-              }
-            ],
-            verdict: "block",
-            reason: "S3 bucket deletion is irreversible \u2014 blocked by AWS shield"
-          },
-          {
-            name: "shield:aws:review-iam-changes",
-            tool: "*",
-            conditions: [
-              {
-                field: "command",
-                op: "matches",
-                value: "aws\\s+iam\\s+(create|delete|attach|detach|put|remove)",
-                flags: "i"
-              }
-            ],
-            verdict: "review",
-            reason: "IAM changes require human approval (AWS shield)"
-          },
-          {
-            name: "shield:aws:block-ec2-terminate",
-            tool: "*",
-            conditions: [
-              {
-                field: "command",
-                op: "matches",
-                value: "aws\\s+ec2\\s+terminate-instances",
-                flags: "i"
-              }
-            ],
-            verdict: "block",
-            reason: "EC2 instance termination is irreversible \u2014 blocked by AWS shield"
-          },
-          {
-            name: "shield:aws:review-rds-delete",
-            tool: "*",
-            conditions: [
-              { field: "command", op: "matches", value: "aws\\s+rds\\s+delete-", flags: "i" }
-            ],
-            verdict: "review",
-            reason: "RDS deletion requires human approval (AWS shield)"
-          }
-        ],
-        dangerousWords: []
-      },
-      "bash-safe": {
-        name: "bash-safe",
-        description: "Blocks high-risk bash patterns: pipe-to-shell, rm -rf /, disk overwrites, eval",
-        aliases: ["bash", "shell"],
-        smartRules: [
-          {
-            name: "shield:bash-safe:block-pipe-to-shell",
-            tool: "bash",
-            conditions: [
-              {
-                field: "command",
-                op: "matches",
-                value: "(curl|wget)\\s+[^|]*\\|\\s*(bash|sh|zsh|fish|python3?|ruby|perl|node)",
-                flags: "i"
-              }
-            ],
-            verdict: "block",
-            reason: "Pipe-to-shell is a common supply-chain attack vector \u2014 blocked by bash-safe shield"
-          },
-          {
-            name: "shield:bash-safe:block-obfuscated-exec",
-            tool: "bash",
-            conditions: [
-              {
-                field: "command",
-                op: "matches",
-                value: "base64\\s+(-d|--decode).*\\|\\s*(bash|sh|zsh)",
-                flags: "i"
-              }
-            ],
-            verdict: "block",
-            reason: "Obfuscated execution via base64 decode \u2014 blocked by bash-safe shield"
-          },
-          {
-            name: "shield:bash-safe:block-rm-root",
-            tool: "bash",
-            conditions: [
-              {
-                field: "command",
-                op: "matches",
-                value: "rm\\s+(-[a-zA-Z]*r[a-zA-Z]*f|-[a-zA-Z]*f[a-zA-Z]*r)[a-zA-Z]*\\s+(\\/|~|\\$HOME|\\$\\{HOME\\})\\s*$",
-                flags: "i"
-              }
-            ],
-            verdict: "block",
-            reason: "rm -rf of root or home directory is catastrophic \u2014 blocked by bash-safe shield"
-          },
-          {
-            name: "shield:bash-safe:block-disk-overwrite",
-            tool: "bash",
-            conditions: [
-              {
-                field: "command",
-                op: "matches",
-                value: "dd\\s+.*of=\\/dev\\/(sd|nvme|hd|vd|xvd)",
-                flags: "i"
-              }
-            ],
-            verdict: "block",
-            reason: "Writing directly to a block device is irreversible \u2014 blocked by bash-safe shield"
-          },
-          {
-            name: "shield:bash-safe:review-eval",
-            tool: "bash",
-            conditions: [
-              {
-                field: "command",
-                op: "matches",
-                value: '\\beval\\s+[\\$`("]',
-                flags: "i"
-              }
-            ],
-            verdict: "review",
-            reason: "eval of dynamic content requires human approval (bash-safe shield)"
-          }
-        ],
-        dangerousWords: []
-      },
-      filesystem: {
-        name: "filesystem",
-        description: "Protects the local filesystem from dangerous AI operations",
-        aliases: ["fs"],
-        smartRules: [
-          {
-            name: "shield:filesystem:review-chmod-777",
-            tool: "bash",
-            conditions: [
-              { field: "command", op: "matches", value: "chmod\\s+(777|a\\+rwx)", flags: "i" }
-            ],
-            verdict: "review",
-            reason: "chmod 777 requires human approval (filesystem shield)"
-          },
-          {
-            name: "shield:filesystem:review-write-etc",
-            tool: "bash",
-            conditions: [
-              {
-                field: "command",
-                // Narrow to write-indicative operations to avoid approval fatigue on reads.
-                // Matches: tee /etc/*, cp .../etc/*, mv .../etc/*, > /etc/*, install .../etc/*
-                op: "matches",
-                value: "(tee|\\bcp\\b|\\bmv\\b|install|>+)\\s+.*\\/etc\\/"
-              }
-            ],
-            verdict: "review",
-            reason: "Writing to /etc requires human approval (filesystem shield)"
-          }
-        ],
-        // dd removed: too common as a legitimate tool (disk imaging, file ops).
-        // mkfs removed: already in the built-in DANGEROUS_WORDS baseline.
-        // wipefs retained: rarely legitimate in an agent context and not in built-ins.
-        dangerousWords: ["wipefs"]
-      }
-    };
+    BUILTIN_DIR = path2.join(__dirname, "shields", "builtin");
+    USER_SHIELDS_DIR = path2.join(os2.homedir(), ".node9", "shields");
+    SHIELDS = buildSHIELDS();
     SHIELDS_STATE_FILE = path2.join(os2.homedir(), ".node9", "shields.json");
   }
 });
@@ -2581,7 +2420,7 @@ function isDaemonRunning() {
     return false;
   }
 }
-async function registerDaemonEntry(toolName, args, meta, riskMetadata, activityId, cwd, recoveryCommand, skipBackgroundAuth, viewOnly) {
+async function registerDaemonEntry(toolName, args, meta, riskMetadata, activityId, cwd, recoveryCommand, skipBackgroundAuth, viewOnly, localSmartRuleMatched) {
   const base = `http://${DAEMON_HOST}:${DAEMON_PORT}`;
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), 5e3);
@@ -2602,7 +2441,8 @@ async function registerDaemonEntry(toolName, args, meta, riskMetadata, activityI
         ...cwd && { cwd },
         ...recoveryCommand && { recoveryCommand },
         ...skipBackgroundAuth && { skipBackgroundAuth: true },
-        ...viewOnly && { viewOnly: true }
+        ...viewOnly && { viewOnly: true },
+        ...localSmartRuleMatched && { localSmartRuleMatched: true }
       }),
       signal: ctrl.signal
     });
@@ -3292,6 +3132,7 @@ async function _authorizeHeadlessCore(toolName, args, meta, options) {
   let policyMatchedWord;
   let riskMetadata;
   let statefulRecoveryCommand;
+  let localSmartRuleMatched = false;
   let taintWarning = null;
   if (isNetworkTool(toolName, args)) {
     const filePaths = extractFilePaths(toolName, args);
@@ -3435,6 +3276,7 @@ async function _authorizeHeadlessCore(toolName, args, meta, options) {
     explainableLabel = policyResult.blockedByLabel || "Local Config";
     policyMatchedField = policyResult.matchedField;
     policyMatchedWord = policyResult.matchedWord;
+    if (policyResult.ruleName) localSmartRuleMatched = true;
     riskMetadata = computeRiskMetadata(
       args,
       policyResult.tier ?? 6,
@@ -3477,22 +3319,26 @@ async function _authorizeHeadlessCore(toolName, args, meta, options) {
   }
   let cloudRequestId = null;
   const cloudEnforced = approvers.cloud && !!creds?.apiKey;
-  if (cloudEnforced) {
+  if (cloudEnforced && !localSmartRuleMatched && !options?.localSmartRuleMatched) {
     try {
       const initResult = await initNode9SaaS(toolName, args, creds, meta, riskMetadata);
       if (!initResult.pending) {
         if (initResult.shadowMode) {
           return { approved: true, checkedBy: "cloud" };
         }
-        return {
-          approved: !!initResult.approved,
-          reason: initResult.reason || (initResult.approved ? void 0 : "Action rejected by organization policy."),
-          checkedBy: initResult.approved ? "cloud" : void 0,
-          blockedBy: initResult.approved ? void 0 : "team-policy",
-          blockedByLabel: "Organization Policy (SaaS)"
-        };
+        if (!localSmartRuleMatched && !options?.localSmartRuleMatched) {
+          return {
+            approved: !!initResult.approved,
+            reason: initResult.reason || (initResult.approved ? void 0 : "Action rejected by organization policy."),
+            checkedBy: initResult.approved ? "cloud" : void 0,
+            blockedBy: initResult.approved ? void 0 : "team-policy",
+            blockedByLabel: "Organization Policy (SaaS)"
+          };
+        }
+      }
+      if (!localSmartRuleMatched && !options?.localSmartRuleMatched) {
+        cloudRequestId = initResult.requestId || null;
       }
-      cloudRequestId = initResult.requestId || null;
       if (!taintWarning) explainableLabel = "Organization Policy (SaaS)";
     } catch {
     }
@@ -3538,7 +3384,10 @@ async function _authorizeHeadlessCore(toolName, args, meta, options) {
           riskMetadata,
           options?.activityId,
           options?.cwd,
-          statefulRecoveryCommand
+          statefulRecoveryCommand,
+          void 0,
+          void 0,
+          localSmartRuleMatched || options?.localSmartRuleMatched
         );
         daemonEntryId = entry.id;
         daemonAllowCount = entry.allowCount;
@@ -3546,7 +3395,7 @@ async function _authorizeHeadlessCore(toolName, args, meta, options) {
       }
     }
   }
-  if (cloudEnforced && cloudRequestId) {
+  if (cloudEnforced && cloudRequestId && !localSmartRuleMatched && !options?.localSmartRuleMatched) {
     racePromises.push(
       (async () => {
         try {
@@ -6213,7 +6062,8 @@ data: ${JSON.stringify(item.data)}
           viewOnly = false,
           fromCLI = false,
           activityId,
-          cwd
+          cwd,
+          localSmartRuleMatched = false
         } = JSON.parse(body);
         const id = fromCLI && typeof activityId === "string" && activityId || randomUUID4();
         const entry = {
@@ -6293,7 +6143,7 @@ data: ${JSON.stringify(item.data)}
             agent: typeof agent === "string" ? agent : void 0,
             mcpServer: typeof mcpServer === "string" ? mcpServer : void 0
           },
-          { calledFromDaemon: true }
+          { calledFromDaemon: true, localSmartRuleMatched: !!localSmartRuleMatched }
         ).then((result) => {
           const e = pending.get(id);
           if (!e) return;
@@ -9136,7 +8986,7 @@ RAW: ${raw}
               }
             }) + "\n"
           );
-          process.exit(0);
+          process.exit(2);
         };
         if (!toolName) {
           sendBlock("Node9: unrecognised hook payload \u2014 tool name missing.");
@@ -9371,6 +9221,27 @@ init_shields();
 init_audit();
 init_config();
 import chalk6 from "chalk";
+
+// src/utils/https-fetch.ts
+import https from "https";
+function httpsFetch(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if (res.statusCode !== 200) {
+        reject(new Error(`HTTP ${String(res.statusCode)} for ${url}`));
+        res.resume();
+        return;
+      }
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+      res.on("error", reject);
+    }).on("error", reject);
+  });
+}
+
+// src/cli/commands/shield.ts
+var COMMUNITY_INDEX_URL = "https://raw.githubusercontent.com/node9ai/node9-proxy/main/shields/community/index.json";
 function registerShieldCommand(program2) {
   const shieldCmd = program2.command("shield").description("Manage pre-packaged security shield templates");
   shieldCmd.command("enable <service>").description("Enable a security shield for a specific service").action((service) => {
@@ -9430,7 +9301,32 @@ function registerShieldCommand(program2) {
 \u{1F6E1}\uFE0F  Shield "${name}" disabled.
 `));
   });
-  shieldCmd.command("list").description("Show all available shields").action(() => {
+  shieldCmd.command("list").description("Show available shields (add --community to browse the marketplace)").option("--community", "List shields available from the community marketplace").action((opts) => {
+    if (opts.community) {
+      console.log(chalk6.bold("\n\u{1F6E1}\uFE0F  Community Shield Marketplace\n"));
+      console.log(chalk6.gray("  Fetching index\u2026\n"));
+      httpsFetch(COMMUNITY_INDEX_URL).then((body) => {
+        const entries = JSON.parse(body);
+        const installed = new Set(listShields().map((s) => s.name));
+        for (const e of entries) {
+          const tag = installed.has(e.name) ? chalk6.green("installed") : chalk6.gray("available");
+          console.log(
+            `  ${tag}  ${chalk6.cyan(e.name.padEnd(12))} ${e.description}  ${chalk6.gray(`by ${e.author}`)}`
+          );
+        }
+        console.log("");
+        console.log(
+          chalk6.gray(`  Install a shield: ${chalk6.cyan("node9 shield install <name>")}
+`)
+        );
+      }).catch((err2) => {
+        console.error(chalk6.red(`
+\u274C Could not fetch community index: ${String(err2)}
+`));
+        process.exit(1);
+      });
+      return;
+    }
     const active = new Set(readActiveShields());
     console.log(chalk6.bold("\n\u{1F6E1}\uFE0F  Available Shields\n"));
     for (const shield of listShields()) {
@@ -9440,6 +9336,10 @@ function registerShieldCommand(program2) {
         console.log(chalk6.gray(`              aliases: ${shield.aliases.join(", ")}`));
     }
     console.log("");
+    console.log(
+      chalk6.gray(`  Browse community shields: ${chalk6.cyan("node9 shield list --community")}
+`)
+    );
   });
   shieldCmd.command("status").description("Show active shields and their individual rules with verdicts").action(() => {
     const active = readActiveShields();
@@ -9577,6 +9477,52 @@ function registerShieldCommand(program2) {
 `)
     );
   });
+  shieldCmd.command("install <name>").description("Install a shield from the community marketplace into ~/.node9/shields/").action((name) => {
+    if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+      console.error(
+        chalk6.red(
+          `
+\u274C Invalid shield name: only alphanumeric characters, hyphens, and underscores are allowed
+`
+        )
+      );
+      process.exit(1);
+    }
+    console.log(chalk6.bold(`
+\u{1F6E1}\uFE0F  Installing shield "${name}"\u2026
+`));
+    httpsFetch(COMMUNITY_INDEX_URL).then((indexBody) => {
+      const entries = JSON.parse(indexBody);
+      const entry = entries.find((e) => e.name === name);
+      if (!entry) {
+        const names = entries.map((e) => chalk6.cyan(e.name)).join(", ");
+        console.error(
+          chalk6.red(`\u274C Shield "${name}" not found in the community marketplace.
+`)
+        );
+        console.error(`  Available: ${names}
+`);
+        process.exit(1);
+      }
+      return httpsFetch(entry.url);
+    }).then((shieldBody) => {
+      const shieldJson = JSON.parse(shieldBody);
+      installShield(name, shieldJson);
+      console.log(
+        chalk6.green(`\u2705  Shield "${name}" installed to ~/.node9/shields/${name}.json`)
+      );
+      console.log(
+        chalk6.gray(`   Activate it with: ${chalk6.cyan(`node9 shield enable ${name}`)}
+`)
+      );
+      appendConfigAudit({ event: "shield-install", shield: name });
+    }).catch((err2) => {
+      console.error(chalk6.red(`
+\u274C Install failed: ${String(err2)}
+`));
+      process.exit(1);
+    });
+  });
 }
 function registerConfigShowCommand(program2) {
   program2.command("config show").description(
@@ -10111,7 +10057,7 @@ import chalk11 from "chalk";
 import fs23 from "fs";
 import path25 from "path";
 import os19 from "os";
-import https from "https";
+import https2 from "https";
 init_shields();
 var DEFAULT_SHIELDS = ["bash-safe", "filesystem", "postgres"];
 function fireTelemetryPing(agents) {
@@ -10122,7 +10068,7 @@ function fireTelemetryPing(agents) {
       os: process.platform,
       node9_version: process.env.npm_package_version ?? "unknown"
     });
-    const req = https.request(
+    const req = https2.request(
       {
         hostname: "api.node9.ai",
         path: "/api/v1/telemetry",