@aarmos/cli 0.1.1 → 0.1.3

package/README.md

@@ -2,6 +2,8 @@
 
 Run your agent locally, across any protocol, with a signed receipt — in 60 seconds.
 
+> **Not what you're looking for?** If you use the browser PWA at [aarmos.io](https://aarmos.io) and want it to reach your local files/shell/git, you want [`@aarmos/bridge`](https://www.npmjs.com/package/@aarmos/bridge) instead. This package is the terminal-native agent runtime.
+
 ```bash
 npm i -g @aarmos/cli
 aarmos init
@@ -16,7 +18,7 @@ aarmos run ./my-agent.js
 | `aarmos run <agent>` | Run agent under policy — writes AVAR receipt on every execution |
 | `aarmos proxy` | Transparent local HTTP proxy on 127.0.0.1 (any framework enrolls via `HTTPS_PROXY`) |
 | `aarmos daemon start|stop|status` | Manage background proxy daemon |
-| `aarmos verify <receipt>` | Discovery wrapper — install standalone `avar` for full verification |
+| `aarmos verify <receipt>` | Verify an AVAR receipt locally (signatures + hash chain, via `@aarmos/avar-core`). Works with the daemon stopped. Zero network. |
 
 ## Guarantees
 

package/dist/index.js

@@ -299,29 +299,404 @@ function isRunning() {
 // src/commands/verify.ts
 import { Command as Command5 } from "commander";
 import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-function verifyCommand() {
-  return new Command5("verify").description(
-    "Thin wrapper on the standalone `avar` binary for discovery. Install `avar` for the full verifier \u2014 it works with the Aarmos daemon stopped."
-  ).argument("<receipt>", "Path to AVAR receipt").action(async (receipt) => {
-    if (!existsSync5(receipt)) {
-      console.error(`\u2717 receipt not found: ${receipt}`);
-      process.exit(2);
+import { unzipSync, strFromU8 } from "fflate";
+
+// ../avar-core/src/canonicalize.ts
+var NFC = (s) => s.normalize("NFC");
+function encodeString(s) {
+  return JSON.stringify(NFC(s));
+}
+function encodeNumber(n) {
+  if (!Number.isFinite(n)) {
+    throw new Error(`avar-core/canonicalize: non-finite number (${n}) is forbidden.`);
+  }
+  return JSON.stringify(n);
+}
+function canonicalize(value) {
+  if (value === null) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") return encodeNumber(value);
+  if (typeof value === "string") return encodeString(value);
+  if (typeof value === "undefined") {
+    throw new Error("avar-core/canonicalize: undefined is forbidden at value position.");
+  }
+  if (typeof value === "function" || typeof value === "symbol" || typeof value === "bigint") {
+    throw new Error(`avar-core/canonicalize: ${typeof value} is forbidden.`);
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map((v) => canonicalize(v)).join(",") + "]";
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = [];
+    for (const k of Object.keys(obj)) {
+      if (obj[k] === void 0) continue;
+      keys.push(NFC(k));
+    }
+    keys.sort();
+    const parts = new Array(keys.length);
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i];
+      const rawVal = obj[k] ?? findKey(obj, k);
+      parts[i] = encodeString(k) + ":" + canonicalize(rawVal);
+    }
+    return "{" + parts.join(",") + "}";
+  }
+  throw new Error(`avar-core/canonicalize: unsupported type ${typeof value}.`);
+}
+function findKey(obj, nfcKey) {
+  for (const k of Object.keys(obj)) {
+    if (NFC(k) === nfcKey) return obj[k];
+  }
+  return void 0;
+}
+function utf8(s) {
+  return new TextEncoder().encode(s);
+}
+
+// ../avar-core/src/hash.ts
+var GENESIS_PREV_HASH = "0000000000000000000000000000000000000000000000000000000000000000";
+function getSubtle() {
+  const c = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+  if (!c || !c.subtle) {
+    throw new Error(
+      "avar-core: WebCrypto SubtleCrypto is unavailable. Requires Node 20+ or a modern browser."
+    );
+  }
+  return c.subtle;
+}
+async function sha256Hex(input) {
+  const bytes = typeof input === "string" ? utf8(input) : input;
+  const digest = await getSubtle().digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function computeEntryHash(entry, prevHash) {
+  const withPrev = { ...entry, prevHash };
+  const {
+    entryHash: _e,
+    signature: _sig,
+    devicePubKey: _pk,
+    ...rest
+  } = withPrev;
+  void _e;
+  void _sig;
+  void _pk;
+  return sha256Hex(prevHash + "\n" + canonicalize(rest));
+}
+async function computeStepHash(step, prevStepHash) {
+  const asRec = step;
+  const { stepHash: _s, prevStepHash: _p, ...rest } = asRec;
+  void _s;
+  void _p;
+  const withPrev = { ...rest, prevStepHash };
+  return sha256Hex(prevStepHash + "\n" + canonicalize(withPrev));
+}
+
+// ../avar-core/src/signature.ts
+function getSubtle2() {
+  const c = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+  if (!c || !c.subtle) {
+    throw new Error("avar-core: WebCrypto SubtleCrypto is unavailable.");
+  }
+  return c.subtle;
+}
+function b64uDecode(s) {
+  const b64 = s.replace(/-/g, "+").replace(/_/g, "/") + "===".slice((s.length + 3) % 4);
+  const bin = typeof atob === "function" ? atob(b64) : globalThis.Buffer.from(b64, "base64").toString("binary");
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+async function verifySignature(signedBody, signatureB64u, publicKeyB64u) {
+  try {
+    const raw = b64uDecode(publicKeyB64u);
+    const key = await getSubtle2().importKey("raw", raw, "Ed25519", false, [
+      "verify"
+    ]);
+    const sig = b64uDecode(signatureB64u);
+    const bytes = utf8(canonicalize(signedBody));
+    return await getSubtle2().verify(
+      "Ed25519",
+      key,
+      sig,
+      bytes
+    );
+  } catch {
+    return false;
+  }
+}
+async function computeDeviceFingerprint(publicKeyB64u) {
+  const hex = await sha256Hex(utf8(publicKeyB64u));
+  return hex.slice(0, 12);
+}
+function signedBodyOf(entry) {
+  const { signature: _sig, devicePubKey: _pk, ...rest } = entry;
+  void _sig;
+  void _pk;
+  return rest;
+}
+
+// ../avar-core/src/verify.ts
+var SPEC_VERSION = "avar/1";
+async function verifyBundle(bundle) {
+  const issues = [];
+  let formatOk = true;
+  const specV = bundle.specVersion.trim();
+  if (specV !== SPEC_VERSION) {
+    formatOk = false;
+    issues.push({
+      index: -1,
+      kind: "spec-version-mismatch",
+      detail: `Expected "${SPEC_VERSION}", got "${specV}".`
+    });
+  }
+  if (bundle.manifest.format !== SPEC_VERSION) {
+    formatOk = false;
+    issues.push({
+      index: -1,
+      kind: "manifest-invalid",
+      detail: `manifest.format expected "${SPEC_VERSION}", got "${bundle.manifest.format}".`
+    });
+  }
+  const actualSha = await sha256Hex(bundle.entriesNdjsonBytes);
+  const entriesSha256Ok = actualSha === bundle.manifest.entriesSha256;
+  if (!entriesSha256Ok) {
+    issues.push({
+      index: -1,
+      kind: "entries-sha256-mismatch",
+      detail: `Expected ${bundle.manifest.entriesSha256}, got ${actualSha}.`
+    });
+  }
+  const entries = bundle.entries;
+  const entryCount = entries.length;
+  let signaturesOk = true;
+  let fingerprintsOk = true;
+  let signedCount = 0;
+  let unsignedCount = 0;
+  for (let i = 0; i < entries.length; i++) {
+    const e = entries[i];
+    const hasSig = typeof e.signature === "string" && typeof e.devicePubKey === "string";
+    if (!hasSig) {
+      unsignedCount++;
+      continue;
     }
-    const raw = readFileSync4(receipt, "utf8");
+    signedCount++;
+    if (typeof e.deviceFingerprint === "string") {
+      const expected = await computeDeviceFingerprint(e.devicePubKey);
+      if (expected !== e.deviceFingerprint) {
+        fingerprintsOk = false;
+        issues.push({
+          index: i,
+          kind: "fingerprint-mismatch",
+          detail: `Expected ${expected}, got ${e.deviceFingerprint}.`
+        });
+      }
+    }
+    const ok = await verifySignature(signedBodyOf(e), e.signature, e.devicePubKey);
+    if (!ok) {
+      signaturesOk = false;
+      issues.push({ index: i, kind: "signature-invalid" });
+    }
+  }
+  let chainOk = true;
+  let unchainedCount = 0;
+  let expectedPrev = GENESIS_PREV_HASH;
+  for (let i = 0; i < entries.length; i++) {
+    const e = entries[i];
+    const isLegacyUnchained = !e.entryHash || !e.prevHash;
+    if (isLegacyUnchained) {
+      unchainedCount++;
+      expectedPrev = GENESIS_PREV_HASH;
+      continue;
+    }
+    if (e.prevHash !== expectedPrev) {
+      chainOk = false;
+      issues.push({
+        index: i,
+        kind: "chain-broken",
+        detail: `prevHash mismatch at entry ${i}.`
+      });
+    }
+    const recomputed = await computeEntryHash(e, e.prevHash);
+    if (recomputed !== e.entryHash) {
+      chainOk = false;
+      issues.push({
+        index: i,
+        kind: "chain-broken",
+        detail: `entryHash mismatch at entry ${i} (body modified after signing).`
+      });
+    }
+    expectedPrev = e.entryHash;
+  }
+  const perStepChainOk = await verifyAllStepChains(entries, issues);
+  const chainHead = computeChainHead(entries);
+  const anyHardFail = !formatOk || !entriesSha256Ok || !chainOk || !perStepChainOk || !signaturesOk || !fingerprintsOk;
+  const verdict = anyHardFail ? "invalid" : unsignedCount > 0 || unchainedCount > 0 ? "valid-with-warnings" : "valid";
+  return {
+    formatOk,
+    entriesSha256Ok,
+    chainOk,
+    perStepChainOk,
+    signaturesOk,
+    fingerprintsOk,
+    entryCount,
+    signedCount,
+    unsignedCount,
+    unchainedCount,
+    chainHead,
+    issues,
+    verdict
+  };
+}
+async function verifyAllStepChains(entries, issues) {
+  let ok = true;
+  for (let i = 0; i < entries.length; i++) {
+    const e = entries[i];
+    if (!Array.isArray(e.steps) || e.steps.length === 0) continue;
+    const anyChained = e.steps.some(hasChainFields);
+    const allChained = e.steps.every(hasChainFields);
+    if (anyChained && !allChained) {
+      ok = false;
+      issues.push({ index: i, kind: "partial-step-chain" });
+      continue;
+    }
+    if (!anyChained) continue;
+    let prev = "step-genesis:0000000000000000000000000000000000000000000000000000000000000000";
+    for (let j = 0; j < e.steps.length; j++) {
+      const s = e.steps[j];
+      if (s.prevStepHash !== prev) {
+        ok = false;
+        issues.push({
+          index: i,
+          kind: "step-chain-broken",
+          detail: `entry ${i} step ${j}: prevStepHash mismatch.`
+        });
+      }
+      const recomputed = await computeStepHash(s, s.prevStepHash);
+      if (recomputed !== s.stepHash) {
+        ok = false;
+        issues.push({
+          index: i,
+          kind: "step-chain-broken",
+          detail: `entry ${i} step ${j}: stepHash mismatch (step body modified).`
+        });
+      }
+      prev = s.stepHash;
+    }
+  }
+  return ok;
+}
+function hasChainFields(s) {
+  return typeof s.prevStepHash === "string" && typeof s.stepHash === "string";
+}
+function computeChainHead(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i];
+    if (e.entryHash) return { entryHash: e.entryHash, index: i };
+  }
+  return { entryHash: "", index: -1 };
+}
+
+// src/commands/verify.ts
+async function runVerify(opts) {
+  const { file, json = false, quiet = false } = opts;
+  if (!existsSync5(file)) {
+    if (!quiet) process.stderr.write(`\u2717 receipt not found: ${file}
+`);
+    return 2;
+  }
+  const bytes = readFileSync4(file);
+  const isZip = looksLikeZip(bytes);
+  if (!isZip) {
     try {
-      const parsed = JSON.parse(raw);
+      const parsed = JSON.parse(bytes.toString("utf8"));
       const entries = Array.isArray(parsed.entries) ? parsed.entries.length : 0;
-      console.log(`\u2713 receipt parsed (${entries} entr${entries === 1 ? "y" : "ies"})`);
-      console.log(`  spec_version: ${parsed.spec_version ?? "unknown"}`);
-      console.log(`  signature_alg: ${parsed.signature_alg ?? "unknown"}`);
-      console.log(
-        "\nFor full signature + hash-chain verification, install the standalone `avar` binary:"
-      );
-      console.log("  https://www.aarmos.io/docs/avar-spec");
+      if (json) {
+        process.stdout.write(
+          JSON.stringify({
+            verdict: "parsed-only",
+            format: "json",
+            entryCount: entries,
+            note: "JSON receipt parsed; full verification requires an .avar.zip bundle."
+          }) + "\n"
+        );
+      } else if (!quiet) {
+        process.stdout.write(`\u2713 receipt parsed (${entries} entr${entries === 1 ? "y" : "ies"})
+`);
+        process.stdout.write(`  spec_version: ${parsed.spec_version ?? "unknown"}
+`);
+        process.stdout.write(`  signature_alg: ${parsed.signature_alg ?? "unknown"}
+`);
+        process.stdout.write(
+          "\nNote: JSON receipts are parse-only. For full signature + hash-chain\nverification, export an .avar.zip bundle.\n"
+        );
+      }
+      return 0;
     } catch (err) {
-      console.error(`\u2717 invalid JSON: ${String(err)}`);
-      process.exit(1);
+      if (!quiet) process.stderr.write(`\u2717 invalid JSON: ${String(err)}
+`);
+      return 1;
+    }
+  }
+  let bundle;
+  try {
+    bundle = parseBundleBytes(bytes);
+  } catch (err) {
+    if (!quiet) process.stderr.write(`\u2717 malformed .avar.zip: ${String(err)}
+`);
+    return 1;
+  }
+  const report = await verifyBundle(bundle);
+  const failed = report.verdict === "invalid";
+  if (json) {
+    process.stdout.write(JSON.stringify(report) + "\n");
+  } else if (!quiet) {
+    const mark = failed ? "\u2717" : "\u2713";
+    process.stdout.write(`${mark} verdict: ${report.verdict}
+`);
+    process.stdout.write(`  entries:   ${report.entryCount}
+`);
+    process.stdout.write(`  signed:    ${report.signedCount}
+`);
+    process.stdout.write(`  unsigned:  ${report.unsignedCount}
+`);
+    process.stdout.write(`  unchained: ${report.unchainedCount}
+`);
+    if (report.issues.length) {
+      process.stdout.write(`  issues:
+`);
+      for (const issue of report.issues) {
+        process.stdout.write(`    - [${issue.kind}] ${issue.detail}
+`);
+      }
     }
+    process.stdout.write("\nverified locally \u2014 no Aarmos service was contacted.\n");
+  }
+  return failed ? 1 : 0;
+}
+function looksLikeZip(bytes) {
+  return bytes.length >= 4 && bytes[0] === 80 && bytes[1] === 75 && bytes[2] === 3 && bytes[3] === 4;
+}
+function parseBundleBytes(bytes) {
+  const files = unzipSync(bytes);
+  const requireFile = (name) => {
+    const f = files[name];
+    if (!f) throw new Error(`missing ${name} in bundle`);
+    return f;
+  };
+  const specVersion = strFromU8(requireFile("SPEC-VERSION")).trim();
+  const manifest = JSON.parse(strFromU8(requireFile("manifest.json")));
+  const pubkeys = JSON.parse(strFromU8(requireFile("pubkeys.json")));
+  const entriesNdjsonBytes = requireFile("entries.ndjson");
+  const entries = strFromU8(entriesNdjsonBytes).split("\n").filter((l) => l.length > 0).map((l) => JSON.parse(l));
+  return { specVersion, manifest, entriesNdjsonBytes, entries, pubkeys };
+}
+function verifyCommand() {
+  return new Command5("verify").description(
+    "Verify an AVAR receipt (.avar.zip bundle or legacy .json) locally \u2014 signatures + hash chain via @aarmos/avar-core. Works with the Aarmos daemon stopped. Zero network."
+  ).argument("<receipt>", "Path to AVAR receipt (.avar.zip or .json)").option("--json", "Emit machine-readable JSON report on stdout").option("--quiet", "Suppress non-error output; exit code carries the verdict").action(async (receipt, opts) => {
+    const rc = await runVerify({ file: receipt, json: opts.json, quiet: opts.quiet });
+    process.exit(rc);
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aarmos/cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Aarmos CLI — run any agent locally, across any protocol (MCP, OpenAPI, deep-link), with a signed AVAR receipt on every execution. Sovereign runtime, universal tool gateway, verifiable governance.",
   "keywords": [
     "aarmos",
@@ -36,14 +36,16 @@
   "author": "Aarmatix LLC",
   "license": "Apache-2.0",
   "dependencies": {
+    "@aarmos/avar-core": "^1.0.0-rc.3",
     "commander": "^12.1.0",
+    "fflate": "^0.8.3",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/node": "^22.5.0",
-    "tsup": "^8.3.0",
+    "tsup": "^8.5.1",
     "tsx": "^4.19.0",
-    "typescript": "^5.6.2"
+    "typescript": "^6.0.3"
   },
   "engines": {
     "node": ">=18.17"