atris 3.82.4 → 3.82.7

package/lib/sentinel-rules.js

@@ -0,0 +1,108 @@
+'use strict';
+
+// The schema for lib/sentinel-rules.json, the literal rules of the guard and
+// the agent check. `atris sentinel improve` may change only that file, so
+// this is the wall between a proposal and the code that judges it:
+//
+//   known keys only, at every level. A missing or extra key is an error
+//   strings and lists of strings only. No functions, no objects where a
+//   list belongs. No `pattern` field anywhere: proposals may add or
+//   remove literal entries, never a regular expression
+//   every entry is a short literal: a host name, a program name, a secret
+//   word, an option name or a command substring. The guard matches them
+//   with plain string operations. There is no pattern to compile and
+//   nothing that can stall on long input
+//
+// validateRules() returns a list of plain problems. Empty means valid.
+
+const MAX_LIST = 300;
+const MAX_ITEM = 200;
+
+const GUARD_KEYS = ['allow_hosts', 'net_tools', 'secret_parts', 'safe_net', 'safe_net_aliases', 'read_only', 'read_only_git', 'db_clients', 'command_blocks'];
+const AGENT_KEYS = ['override_substrings', 'secret_env_names'];
+const SAFE_NET_KEYS = ['flags', 'values', 'local_values', 'short_flags', 'short_values', 'items'];
+const BLOCK_KEYS = ['id', 'category', 'all', 'programs'];
+
+const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+
+// A proposal may never carry a regex. `pattern` is the field name the old
+// shape used. It is called out by name wherever it appears.
+function noPatternField(obj, where, problems) {
+  if (isObj(obj) && 'pattern' in obj) problems.push(`${where} has a pattern field. proposals may add literal entries only, never a regular expression`);
+}
+
+function exactKeys(obj, allowed, where, problems, optional = []) {
+  for (const k of Object.keys(obj)) if (!allowed.includes(k)) problems.push(`${where} has an unknown key: ${k}`);
+  for (const k of allowed) if (!optional.includes(k) && !(k in obj)) problems.push(`${where} is missing ${k}`);
+}
+
+function strList(v, where, problems, shape = null, maxItem = MAX_ITEM) {
+  if (!Array.isArray(v)) { problems.push(`${where} must be a list`); return; }
+  if (v.length > MAX_LIST) problems.push(`${where} has more than ${MAX_LIST} items`);
+  v.forEach((x, i) => {
+    if (typeof x !== 'string') problems.push(`${where}[${i}] must be a string`);
+    else if (!x.length) problems.push(`${where}[${i}] is empty`);
+    else if (x.length > maxItem) problems.push(`${where}[${i}] is longer than ${maxItem} characters`);
+    else if (shape && !shape.test(x)) problems.push(`${where}[${i}] has an odd shape: ${x.slice(0, 40)}`);
+  });
+}
+
+function validateRules(rules) {
+  const problems = [];
+  if (!isObj(rules)) return ['the rules file must hold one object'];
+  exactKeys(rules, ['version', 'guard', 'agents'], 'the rules file', problems);
+  if (rules.version !== 2) problems.push('version must be 2');
+  const g = rules.guard;
+  if (!isObj(g)) problems.push('guard must be an object');
+  else {
+    noPatternField(g, 'guard', problems);
+    exactKeys(g, GUARD_KEYS, 'guard', problems);
+    strList(g.allow_hosts, 'guard.allow_hosts', problems, /^[a-z0-9.:_-]{1,100}$/i);
+    for (const k of ['net_tools', 'read_only', 'db_clients']) strList(g[k], `guard.${k}`, problems, /^[A-Za-z0-9._+[-]{1,40}$/);
+    strList(g.read_only_git, 'guard.read_only_git', problems, /^[a-z-]{1,30}$/);
+    strList(g.secret_parts, 'guard.secret_parts', problems, /^[A-Z0-9]{1,30}$/);
+    if (!isObj(g.safe_net)) problems.push('guard.safe_net must be an object');
+    else {
+      for (const [prog, spec] of Object.entries(g.safe_net)) {
+        const where = `guard.safe_net.${prog}`;
+        if (!/^[a-z]{1,20}$/.test(prog)) problems.push(`${where} is not a program name`);
+        if (!isObj(spec)) { problems.push(`${where} must be an object`); continue; }
+        noPatternField(spec, where, problems);
+        exactKeys(spec, SAFE_NET_KEYS, where, problems);
+        for (const k of ['flags', 'values', 'local_values']) strList(spec[k], `${where}.${k}`, problems, /^--?[A-Za-z0-9][A-Za-z0-9-]{0,40}$/);
+        for (const k of ['short_flags', 'short_values']) if (typeof spec[k] !== 'string' || !/^[A-Za-z]{0,30}$/.test(spec[k])) problems.push(`${where}.${k} must be letters`);
+        if (typeof spec.items !== 'boolean') problems.push(`${where}.items must be true or false`);
+      }
+    }
+    if (!isObj(g.safe_net_aliases)) problems.push('guard.safe_net_aliases must be an object');
+    else for (const [alias, target] of Object.entries(g.safe_net_aliases)) {
+      if (!/^[a-z]{1,20}$/.test(alias) || typeof target !== 'string' || !(isObj(g.safe_net) && g.safe_net[target])) problems.push(`guard.safe_net_aliases.${alias} must name a program in safe_net`);
+    }
+    if (!Array.isArray(g.command_blocks)) problems.push('guard.command_blocks must be a list');
+    else {
+      if (g.command_blocks.length > 50) problems.push('guard.command_blocks has more than 50 items');
+      g.command_blocks.forEach((b, i) => {
+        const where = `guard.command_blocks[${i}]`;
+        if (!isObj(b)) { problems.push(`${where} must be an object`); return; }
+        noPatternField(b, where, problems);
+        exactKeys(b, BLOCK_KEYS, where, problems, ['programs']);
+        if (typeof b.id !== 'string' || !/^[a-z0-9-]{1,40}$/.test(b.id)) problems.push(`${where}.id must be short lowercase words`);
+        if (!['exfil', 'destroy', 'disarm'].includes(b.category)) problems.push(`${where}.category must be exfil, destroy or disarm`);
+        strList(b.all, `${where}.all`, problems);
+        if (Array.isArray(b.all) && !b.all.length) problems.push(`${where}.all needs at least one substring`);
+        if ('programs' in b) strList(b.programs, `${where}.programs`, problems, /^[A-Za-z0-9._+-]{1,40}$/);
+      });
+    }
+  }
+  const a = rules.agents;
+  if (!isObj(a)) problems.push('agents must be an object');
+  else {
+    noPatternField(a, 'agents', problems);
+    exactKeys(a, AGENT_KEYS, 'agents', problems);
+    strList(a.override_substrings, 'agents.override_substrings', problems);
+    strList(a.secret_env_names, 'agents.secret_env_names', problems, /^[A-Za-z_][A-Za-z0-9_.-]{0,80}$/);
+  }
+  return problems;
+}
+
+module.exports = { validateRules };

package/lib/sentinel-rules.json

@@ -0,0 +1,237 @@
+{
+  "version": 2,
+  "guard": {
+    "allow_hosts": [
+      "localhost",
+      "127.0.0.1",
+      "0.0.0.0",
+      "::1",
+      "api.github.com",
+      "github.com",
+      "uploads.github.com",
+      "api.openai.com",
+      "api.anthropic.com",
+      "registry.npmjs.org",
+      "pypi.org",
+      "upload.pypi.org",
+      "api.atris.ai",
+      "atris.ai",
+      "api.stripe.com",
+      "slack.com",
+      "api.vercel.com",
+      "api.render.com"
+    ],
+    "net_tools": [
+      "curl",
+      "wget",
+      "nc",
+      "ncat",
+      "netcat",
+      "socat",
+      "telnet",
+      "scp",
+      "sftp",
+      "ftp",
+      "rsync",
+      "http",
+      "https",
+      "xh",
+      "httpie",
+      "aria2c",
+      "lftp",
+      "ssh"
+    ],
+    "secret_parts": [
+      "KEY",
+      "KEYS",
+      "TOKEN",
+      "TOKENS",
+      "SECRET",
+      "SECRETS",
+      "PASSWORD",
+      "PASSWD",
+      "PASS",
+      "PWD",
+      "CREDENTIAL",
+      "CREDENTIALS",
+      "CREDS",
+      "AUTH",
+      "PRIVATE",
+      "SESSION",
+      "COOKIE",
+      "APIKEY",
+      "PAT",
+      "DSN"
+    ],
+    "safe_net": {
+      "curl": {
+        "flags": [
+          "-s",
+          "--silent",
+          "-S",
+          "--show-error",
+          "-f",
+          "--fail",
+          "--fail-with-body",
+          "--fail-early",
+          "-L",
+          "--location",
+          "-O",
+          "--remote-name",
+          "-i",
+          "--include",
+          "-v",
+          "--verbose",
+          "--compressed",
+          "-G",
+          "--get"
+        ],
+        "values": [
+          "-H",
+          "--header",
+          "-d",
+          "--data",
+          "--data-raw",
+          "--data-binary",
+          "--data-urlencode",
+          "--data-ascii",
+          "--json",
+          "-X",
+          "--request",
+          "-o",
+          "--output",
+          "-w",
+          "--write-out",
+          "-m",
+          "--max-time"
+        ],
+        "local_values": [
+          "-o",
+          "--output"
+        ],
+        "short_flags": "sSfLOivG",
+        "short_values": "HdXowm",
+        "items": false
+      },
+      "wget": {
+        "flags": [
+          "-q",
+          "--quiet",
+          "-S",
+          "--server-response",
+          "-nv",
+          "--no-verbose"
+        ],
+        "values": [
+          "-O",
+          "--output-document",
+          "--header",
+          "--post-data",
+          "--method",
+          "--body-data",
+          "-T",
+          "--timeout",
+          "-t",
+          "--tries"
+        ],
+        "local_values": [
+          "-O",
+          "--output-document"
+        ],
+        "short_flags": "qS",
+        "short_values": "OTt",
+        "items": false
+      },
+      "http": {
+        "flags": [
+          "-j",
+          "--json",
+          "-f",
+          "--form",
+          "-h",
+          "--headers",
+          "-b",
+          "--body",
+          "-v",
+          "--verbose",
+          "--check-status",
+          "--ignore-stdin"
+        ],
+        "values": [
+          "-p",
+          "--print",
+          "--timeout",
+          "-o",
+          "--output"
+        ],
+        "local_values": [
+          "-o",
+          "--output"
+        ],
+        "short_flags": "jfhbv",
+        "short_values": "po",
+        "items": true
+      }
+    },
+    "safe_net_aliases": {
+      "https": "http",
+      "xh": "http",
+      "httpie": "http"
+    },
+    "read_only": [
+      "cat",
+      "less",
+      "more",
+      "head",
+      "tail",
+      "grep",
+      "egrep",
+      "fgrep",
+      "rg",
+      "jq",
+      "ls",
+      "stat",
+      "wc",
+      "file",
+      "diff",
+      "echo",
+      "test",
+      "[",
+      "realpath",
+      "readlink"
+    ],
+    "read_only_git": [
+      "diff",
+      "log",
+      "show",
+      "status"
+    ],
+    "db_clients": [
+      "psql",
+      "pg_restore",
+      "mysql",
+      "mariadb",
+      "sqlite3",
+      "sqlite",
+      "sqlcmd",
+      "mongosh",
+      "mongo",
+      "redis-cli",
+      "clickhouse-client",
+      "clickhouse",
+      "cockroach",
+      "duckdb",
+      "supabase",
+      "prisma",
+      "turso",
+      "wrangler",
+      "neonctl",
+      "cqlsh"
+    ],
+    "command_blocks": []
+  },
+  "agents": {
+    "override_substrings": [],
+    "secret_env_names": []
+  }
+}

package/lib/sentinel-watch.js

@@ -341,25 +341,31 @@ async function runWatch(root, { base = process.env.ATRIS_OSV_BASE || OSV_BASE, r
 
 // ---------------------------------------------------------------- events
 
+// The dashboard only accepts plain words, so a package name like @vitest/mocker
+// or lodash.merge is written as vitest-mocker or lodash-merge.
+function plainName(name) {
+  return String(name || '').replace(/^@/, '').replace(/[\/._]+/g, '-').replace(/[^A-Za-z0-9-]/g, '').replace(/-+/g, '-').replace(/^-|-$/g, '');
+}
+
 function threatTitle(a) {
-  const kind = events.slotOk('package', a.name) ? 'package' : 'module';
-  const slots = { pkg: [kind, a.name, 'one'], fixed: ['version', a.fixed, 'a newer version'] };
-  const subject = events.slotOk(kind, a.name) ? 'the {pkg} package you use' : 'a package you use';
+  const name = plainName(a.name);
+  const kind = events.slotOk('package', name) ? 'package' : 'module';
+  const slots = { pkg: [kind, name, 'one'], fixed: ['version', a.fixed, 'a newer version'] };
+  const subject = events.slotOk(kind, name) ? 'the {pkg} package you use' : 'a package you use';
   if (a.malicious) return events.fillPlain(`A published attack affects ${subject}. Remove it or move to a version that is not affected.`, slots);
   if (a.fixed) return events.fillPlain(`A known security hole affects ${subject}. Version {fixed} fixes it.`, slots);
   return events.fillPlain(`A known security hole affects ${subject}. No fixed version is published yet.`, slots);
 }
 
 function threatDetail(a) {
-  const ids = a.advisories.filter((id) => events.slotOk('advisory', id)).slice(0, 5);
   const one = a.advisories.length === 1;
   const slots = { n: ['count', String(a.advisories.length), 'some'], fixed: ['version', a.fixed, 'a newer version'], current: ['version', a.version, 'the current version'] };
   const found = one ? 'Found in one published advisory against version {current}.' : 'Found in {n} published advisories against version {current}.';
   const head = a.fixed
     ? events.fillPlain(`${found} Update to version {fixed} or later and run your tests.`, slots, 1000)
     : events.fillPlain(`${found} Watch for a fix or replace the package.`, slots, 1000);
-  const tail = ids.length ? ` Advisories: ${ids.join(' ')}.` : '';
-  return `${head}${tail}`.slice(0, 1000);
+  // Advisory codes stay in the local report: mixed letter and digit codes read as keys to the dashboard's secret check.
+  return head.slice(0, 1000);
 }
 
 function toEvents(result, { repo, now = new Date() } = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.82.4",
+  "version": "3.82.7",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof. project memory your coding agents share across sessions.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",