tamperward 2.13.0 → 2.13.1

package/README.md

@@ -336,9 +336,13 @@ from trusted CI, or after an externally isolated agent hands off the frozen cand
 
 ### CLI reference
 
-Every flag below is what the command's parser actually reads (`src/cli/index.ts`,
-`parseVerify`, `parseRun`). `check` reports an unknown flag on stderr; the other
-commands ignore what they do not know.
+Every flag below is what the command's parser actually reads (`src/cli/main.ts`,
+`parseVerify`, `parseRun`). Since **2.13.1**, user-supplied argv is validated before
+any command-specific parser or side effect runs: unknown options, missing values,
+invalid numeric budgets/timeouts, duplicate/conflicting `check` views, and unexpected
+positionals fail closed with exit 2 and one deterministic `tamperward: ...` diagnostic.
+`run` requires an explicit `--` before the wrapped command, so a typoed TamperWard
+option can never be reinterpreted as the agent command.
 
 | command | flags |
 | --- | --- |

package/dist/cli/index.js

@@ -308,8 +308,8 @@ function inspectOnce(abs2) {
   try {
     st = lstatSync(abs2);
   } catch (e) {
-    const code = errCode(e);
-    if (code === "ENOENT" || code === "ENOTDIR") return { kind: "absent", content: null, ...NO_META, detail: "" };
+    const code2 = errCode(e);
+    if (code2 === "ENOENT" || code2 === "ENOTDIR") return { kind: "absent", content: null, ...NO_META, detail: "" };
     return { kind: "unreadable", content: null, ...NO_META, detail: errText(e) };
   }
   if (st.isSymbolicLink() || !st.isFile()) return classify(abs2, st);
@@ -320,8 +320,8 @@ function inspectPath(abs2) {
   try {
     st = lstatSync(abs2);
   } catch (e) {
-    const code = errCode(e);
-    if (code === "ENOENT" || code === "ENOTDIR") return { kind: "absent", content: null, ...NO_META, detail: "" };
+    const code2 = errCode(e);
+    if (code2 === "ENOENT" || code2 === "ENOTDIR") return { kind: "absent", content: null, ...NO_META, detail: "" };
     return { kind: "unreadable", content: null, ...NO_META, detail: errText(e) };
   }
   return classify(abs2, st);
@@ -334,8 +334,8 @@ function inspectResolved(abs2) {
   try {
     real = realpathSync(abs2);
   } catch (e) {
-    const code = errCode(e);
-    if (code === "ENOENT" || code === "ENOTDIR") return { kind: "absent", content: null, ...NO_META, detail: "" };
+    const code2 = errCode(e);
+    if (code2 === "ENOENT" || code2 === "ENOTDIR") return { kind: "absent", content: null, ...NO_META, detail: "" };
     return { kind: "unreadable", content: null, ...NO_META, detail: errText(e) };
   }
   return inspectPath(real);
@@ -2669,8 +2669,8 @@ var CODE_PROBES = ["src/index.ts", "src/index.js", "lib/index.js", "index.ts", "
 function sourceProbes(ctx) {
   const files = trackedFiles(ctx);
   if (!files) return CODE_PROBES;
-  const code = files.filter((f) => langOf(f) !== null);
-  return code.length ? code : CODE_PROBES;
+  const code2 = files.filter((f) => langOf(f) !== null);
+  return code2.length ? code2 : CODE_PROBES;
 }
 function triggerNarrowings(before, after, opts) {
   const out2 = [];
@@ -6535,8 +6535,8 @@ function terminalWidth(stream = process.stdout) {
   if (!c || c < 40) return 80;
   return Math.min(c, 100);
 }
-function paint(s, code, on) {
-  return on ? code + s + RESET : s;
+function paint(s, code2, on) {
+  return on ? code2 + s + RESET : s;
 }
 function wrap(text, width) {
   const out2 = [];
@@ -9317,8 +9317,8 @@ function runContainerStage(backend, dir, command, budgetSecs) {
     const secs = Math.round((Date.now() - t0) / 1e3);
     if (r.error) {
       cleanupContainer(backend, name);
-      const code = r.error.code;
-      return code === "ETIMEDOUT" ? { exit: null, secs, failure: "budget", reason: "verifier stage exceeded its budget" } : { exit: null, secs, failure: "backend", reason: `Docker client failed: ${r.error.message}` };
+      const code2 = r.error.code;
+      return code2 === "ETIMEDOUT" ? { exit: null, secs, failure: "budget", reason: "verifier stage exceeded its budget" } : { exit: null, secs, failure: "backend", reason: `Docker client failed: ${r.error.message}` };
     }
     if (r.status === null) {
       cleanupContainer(backend, name);
@@ -9942,22 +9942,22 @@ function runVerify(opts) {
     return 2;
   }
   let verdict2;
-  let code;
+  let code2;
   if (visible.exit === null || pristine.exit === null) {
     verdict2 = "BUDGET_EXCEEDED";
-    code = 2;
+    code2 = 2;
   } else if (visible.exit === 0 && pristine.exit === 0) {
     verdict2 = "VERIFIED";
-    code = 0;
+    code2 = 0;
   } else if (visible.exit === 0) {
     verdict2 = "MASKED_FAILURE";
-    code = 1;
+    code2 = 1;
   } else {
     verdict2 = "SUITE_RED";
-    code = 1;
+    code2 = 1;
   }
   const signedOff = verdict2 === "MASKED_FAILURE" ? oobToken("verify", oobFromEnv(), oobHeadFromEnv()) : null;
-  if (signedOff) code = 0;
+  if (signedOff) code2 = 0;
   if (opts.json) {
     out2(
       JSON.stringify({
@@ -10000,7 +10000,7 @@ function runVerify(opts) {
         `(${removedAdded} protected file(s) added since ${base.slice(0, 10)} were removed from the pristine run: the pristine tree carries exactly the base's protected surface.)`
       );
   }
-  return code;
+  return code2;
 }
 function parseVerify(args) {
   const o = {};
@@ -10567,17 +10567,148 @@ function parseCheck(args) {
     else if (a === "--format") {
       const v = args[++i];
       if (v !== void 0 && isFormat(v)) o.format = v;
-      else process.stderr.write(`tamperward: unknown --format "${v ?? ""}" (expected ${FORMATS.join(" | ")})
-`);
     } else if (a === "--diff") o.diff = args[++i];
     else if (a === "--cwd") o.cwd = args[++i];
-    else {
-      process.stderr.write(`tamperward: unknown flag "${a}"
-`);
-    }
   }
   return o;
 }
+function validateFlatArgs(args, grammar) {
+  const flags = new Set(grammar.flags ?? []);
+  const values = grammar.values ?? {};
+  const seen = /* @__PURE__ */ new Set();
+  const positionals = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (flags.has(a) || Object.prototype.hasOwnProperty.call(values, a)) {
+      if (seen.has(a)) {
+        return { error: `option "${a}" specified more than once`, seen, positionals };
+      }
+      seen.add(a);
+      const rule = values[a];
+      if (!rule) continue;
+      const v = args[i + 1];
+      if (v === void 0 || v.startsWith("--")) {
+        return {
+          error: `${a} needs a value` + (v === void 0 ? "" : ` (got the flag "${v}")`),
+          seen,
+          positionals
+        };
+      }
+      i++;
+      if (rule === "positive") {
+        const n = Number(v);
+        if (!Number.isFinite(n) || n <= 0) {
+          return { error: `${a} needs a positive number (got "${v}")`, seen, positionals };
+        }
+      } else if (rule === "non-negative") {
+        const n = Number(v);
+        if (!Number.isFinite(n) || n < 0) {
+          return { error: `${a} needs a non-negative number (got "${v}")`, seen, positionals };
+        }
+      } else if (rule === "format" && !isFormat(v)) {
+        return {
+          error: `--format needs one of ${FORMATS.join(" | ")} (got "${v}")`,
+          seen,
+          positionals
+        };
+      }
+      continue;
+    }
+    if (a.startsWith("-")) {
+      return { error: `unknown option "${a}"`, seen, positionals };
+    }
+    if (grammar.positional === "one" && positionals.length === 0) {
+      positionals.push(a);
+      continue;
+    }
+    return { error: `unexpected argument "${a}"`, seen, positionals };
+  }
+  return { seen, positionals };
+}
+function validateCliArgs(cmd, args) {
+  if (cmd === "hook" || cmd === "sweep") {
+    if (args.length === 0) return `${cmd} requires an agent name`;
+    if (args.length > 1) return `unexpected argument "${args[1]}"`;
+    return void 0;
+  }
+  if (cmd === "run") {
+    const delimiter3 = args.indexOf("--");
+    if (delimiter3 < 0) return 'run requires an explicit "--" before the wrapped command';
+    const prefix = args.slice(0, delimiter3);
+    const command = args.slice(delimiter3 + 1);
+    const parsed = validateFlatArgs(prefix, {
+      flags: ["--allow-dirty", "--allow-dep-drift"],
+      values: {
+        "--base": "string",
+        "--cmd": "string",
+        "--budget": "positive",
+        "--agent-budget": "positive",
+        "--settle": "non-negative",
+        "--cwd": "string"
+      }
+    });
+    if (parsed.error) return parsed.error;
+    if (command.length === 0) return 'run requires a wrapped command after "--"';
+    return void 0;
+  }
+  if (cmd === "check") {
+    const parsed = validateFlatArgs(args, {
+      flags: ["--staged", "--worktree", "--json"],
+      values: { "--diff": "string", "--format": "format", "--cwd": "string" }
+    });
+    if (parsed.error) return parsed.error;
+    const views = ["--staged", "--worktree", "--diff"].filter((x) => parsed.seen.has(x));
+    if (views.length > 1) return "choose exactly one of --staged, --worktree, or --diff";
+    if (parsed.seen.has("--json") && parsed.seen.has("--format")) {
+      return "--json cannot be combined with --format";
+    }
+    return void 0;
+  }
+  if (cmd === "allow") {
+    const parsed = validateFlatArgs(args, {
+      values: { "--file": "string", "--reason": "string", "--cwd": "string" },
+      positional: "one"
+    });
+    if (parsed.error) return parsed.error;
+    if (parsed.positionals.length === 0) return "allow requires a rule";
+    return void 0;
+  }
+  if (cmd === "init") {
+    return validateFlatArgs(args, {
+      flags: ["--dry-run", "--force-workflow"],
+      values: { "--cwd": "string" }
+    }).error;
+  }
+  if (cmd === "doctor") {
+    return validateFlatArgs(args, {
+      flags: ["--github"],
+      values: {
+        "--cwd": "string",
+        "--base": "string",
+        "--workflow": "string",
+        "--repo": "string",
+        "--branch": "string"
+      }
+    }).error;
+  }
+  if (cmd === "verify") {
+    return validateFlatArgs(args, {
+      flags: ["--json", "--keep", "--require-ancestor"],
+      values: {
+        "--base": "string",
+        "--cmd": "string",
+        "--cwd": "string",
+        "--budget": "positive"
+      }
+    }).error;
+  }
+  if (cmd === "watch") {
+    return validateFlatArgs(args, {
+      values: { "--dir": "string", "--log": "string" }
+    }).error;
+  }
+  return void 0;
+}
 function printHelp() {
   process.stdout.write(`tamperward \u2014 the deterministic agent-integrity gate
 
@@ -10652,6 +10783,14 @@ Exit codes: 0 clean \xB7 1 a blocking finding (check), MASKED_FAILURE or SUITE_R
 }
 function main(argv2) {
   const [cmd, ...rest] = argv2;
+  if (cmd !== void 0 && cmd !== "-h" && cmd !== "--help") {
+    const invalid = validateCliArgs(cmd, rest);
+    if (invalid) {
+      process.stderr.write(`tamperward: ${invalid}
+`);
+      return 2;
+    }
+  }
   switch (cmd) {
     case "check":
       return runCheck(parseCheck(rest));
@@ -10665,6 +10804,8 @@ function main(argv2) {
       return runInit(parseInit(rest));
     case "doctor":
       return runDoctor(parseDoctor(rest));
+    case "watch":
+      return runWatch(rest);
     case "verify":
       return runVerify(parseVerify(rest));
     case "run":
@@ -10694,8 +10835,5 @@ function guardedMain(argv2, stderr = process.stderr) {
 
 // src/cli/index.ts
 var argv = process.argv.slice(2);
-if (argv[0] === "watch") {
-  runWatch(argv.slice(1));
-} else {
-  process.exit(guardedMain(argv));
-}
+var code = guardedMain(argv);
+if (code >= 0) process.exit(code);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tamperward",
-  "version": "2.13.0",
+  "version": "2.13.1",
   "description": "The deterministic agent-integrity gate. One ruleset, evaluated on the actual diff/commands as a verdict, enforced everywhere a change can be made.",
   "license": "Apache-2.0",
   "author": "hexrift",