@fidacy/openclaw-plugin 0.1.8 → 0.1.10

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.10 — 2026-07-03
+
+- Artifact tools gain the `conversation` kind (chatbot session digests via
+  `@fidacy/session`, conversation receipts).
+
+## 0.1.9 — 2026-07-03
+
+- New tools: `anchor_artifact` and `check_artifact` (hash-only artifact anchoring
+  on the Bitcoin-checkpointed audit chain; files never leave the machine).
+
 ## 0.1.1 — 2026-07-02
 
 - README: animated demo (BEC lookalike-payee DENY → legit ALLOW with signed

package/dist/index.js

@@ -4671,7 +4671,7 @@ function resolveMandateRules(cfg) {
 }
 
 // ../mcp/src/telemetry.ts
-var CLIENT_VERSION = true ? "0.1.8" : "dev";
+var CLIENT_VERSION = true ? "0.1.10" : "dev";
 var currentShell = "mcp";
 function setTelemetryShell(shell) {
   currentShell = shell;
@@ -4799,7 +4799,7 @@ function requestUpgrade() {
 }
 
 // ../mcp/src/provision.ts
-var CLIENT_VERSION2 = true ? "0.1.8" : "dev";
+var CLIENT_VERSION2 = true ? "0.1.10" : "dev";
 function provisionEnabled() {
   const v = (process.env.FIDACY_DISABLE_PROVISION ?? "").trim().toLowerCase();
   return !(v === "1" || v === "true" || v === "yes");
@@ -4988,6 +4988,71 @@ async function postOnce(fetchImpl, url, headers, payload, timeoutMs) {
   return parsed;
 }
 
+// ../mcp/src/artifacts.ts
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { pipeline } from "node:stream/promises";
+var ARTIFACT_KINDS = [
+  "contract",
+  "invoice",
+  "prescription",
+  "claim",
+  "document",
+  "image",
+  "audio",
+  "video",
+  "conversation",
+  "custom"
+];
+async function hashFile(path) {
+  const hash = createHash("sha256");
+  await pipeline(createReadStream(path), async function* (source) {
+    for await (const chunk of source) {
+      hash.update(chunk);
+      yield;
+    }
+  });
+  return hash.digest("hex");
+}
+async function engineFetch(method, pathAndQuery, cfg, body) {
+  const base = requireSafeBaseUrl(cfg.engineUrl);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 1e4);
+  let res;
+  try {
+    res = await fetch(`${base}${pathAndQuery}`, {
+      method,
+      headers: {
+        authorization: `Bearer ${cfg.apiKey}`,
+        ...body !== void 0 ? { "content-type": "application/json" } : {}
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0,
+      signal: controller.signal
+    });
+  } catch {
+    throw new AssessError({ type: "network_error", status: 0 });
+  } finally {
+    clearTimeout(timer);
+  }
+  let json;
+  try {
+    json = await res.json();
+  } catch {
+    throw new AssessError({ type: "bad_response", status: res.status });
+  }
+  if (!res.ok) {
+    const type = typeof json?.error === "string" ? String(json.error) : "engine_error";
+    throw new AssessError({ type, status: res.status });
+  }
+  return json;
+}
+async function anchorArtifact(params, cfg) {
+  return await engineFetch("POST", "/v1/artifacts", cfg, params);
+}
+async function findArtifacts(sha2562, cfg) {
+  return await engineFetch("GET", `/v1/artifacts?sha256=${sha2562}`, cfg);
+}
+
 // src/index.ts
 var core;
 function boot() {
@@ -5129,6 +5194,105 @@ ${d.grant}` : `DENY (decision ${d.decisionId}). Rule violated: ${d.violatedRule}
         }
       }
     }),
+    // ARTIFACT ANCHORING. Hash-only integrity/existence proof: the file is hashed
+    // locally (streaming) and never uploaded; the SHA-256 joins the same
+    // Bitcoin-checkpointed audit chain as the verdicts. Receipt = offline JWS.
+    tool({
+      name: "anchor_artifact",
+      label: "Anchor Artifact (Bitcoin-anchored integrity proof)",
+      description: "Prove an artifact existed exactly as-is at this moment, and make any later tampering detectable. Give a file `path` (hashed locally with SHA-256 \u2014 the file itself is NEVER uploaded) or a precomputed `sha256`. The hash is registered on Fidacy's tamper-evident audit chain, which is checkpointed to the Bitcoin blockchain, and you get a signed receipt (JWS) verifiable offline against the engine JWKS. Use it for contracts, invoices, medical prescriptions, insurance claims, images, audio, video. `kind` defaults to document; optional `label` is a short reference (no PII).",
+      parameters: typebox_exports.Object({
+        path: typebox_exports.Optional(typebox_exports.String()),
+        sha256: typebox_exports.Optional(typebox_exports.String({ pattern: "^[0-9a-f]{64}$" })),
+        kind: typebox_exports.Optional(typebox_exports.Union(ARTIFACT_KINDS.map((k) => typebox_exports.Literal(k)))),
+        label: typebox_exports.Optional(typebox_exports.String({ maxLength: 120 })),
+        subject: typebox_exports.Optional(typebox_exports.String({ maxLength: 120 }))
+      }),
+      async execute(params, config) {
+        boot();
+        const engineUrl = config.engineUrl ?? process.env.FIDACY_ENGINE_URL ?? "https://api.fidacy.com";
+        const apiKey = (config.engineApiKey ?? process.env.FIDACY_ENGINE_API_KEY ?? "").trim();
+        if (!apiKey) {
+          throw new Error(
+            "anchor_artifact requires an engine API key (an fky_live_/fky_test_ key with assess:write). Set plugins.entries.fidacy.config.engineApiKey or FIDACY_ENGINE_API_KEY."
+          );
+        }
+        if (!params.path && !params.sha256) {
+          throw new Error("Give a file `path` (hashed locally) or a precomputed `sha256`.");
+        }
+        let hash = params.sha256 ?? "";
+        if (!hash && params.path) {
+          try {
+            hash = await hashFile(params.path);
+          } catch {
+            throw new Error("Could not read that file locally (check the path and permissions). Nothing was sent anywhere.");
+          }
+        }
+        try {
+          const r = await anchorArtifact(
+            { sha256: hash, kind: params.kind ?? "document", ...params.label ? { label: params.label } : {}, ...params.subject ? { subject: params.subject } : {} },
+            { engineUrl, apiKey }
+          );
+          return {
+            summary: `ANCHORED ${r.kind} \xB7 sha256 ${hash.slice(0, 16)}\u2026 \xB7 audit seq ${r.audit.seq} \xB7 Bitcoin checkpoint: ${r.anchor.status}. The file never left this machine.`,
+            ...r
+          };
+        } catch (e) {
+          if (e instanceof AssessError) throw new Error(`ANCHOR ${e.status}: ${e.type}`);
+          throw new Error("ANCHOR failed: unexpected error");
+        }
+      }
+    }),
+    // Verification half: was this exact content anchored, and did it reach Bitcoin?
+    tool({
+      name: "check_artifact",
+      label: "Check Artifact (was this hash anchored?)",
+      description: "Check whether an artifact was anchored by this account and the state of its Bitcoin checkpoint. Give a file `path` (hashed locally, never uploaded) or a `sha256`. If the current hash of a file does NOT match an anchored record you expected, the file changed since anchoring \u2014 that is the tampering signal.",
+      parameters: typebox_exports.Object({
+        path: typebox_exports.Optional(typebox_exports.String()),
+        sha256: typebox_exports.Optional(typebox_exports.String({ pattern: "^[0-9a-f]{64}$" }))
+      }),
+      async execute(params, config) {
+        boot();
+        const engineUrl = config.engineUrl ?? process.env.FIDACY_ENGINE_URL ?? "https://api.fidacy.com";
+        const apiKey = (config.engineApiKey ?? process.env.FIDACY_ENGINE_API_KEY ?? "").trim();
+        if (!apiKey) {
+          throw new Error(
+            "check_artifact requires an engine API key. Set plugins.entries.fidacy.config.engineApiKey or FIDACY_ENGINE_API_KEY."
+          );
+        }
+        if (!params.path && !params.sha256) {
+          throw new Error("Give a file `path` (hashed locally) or a `sha256`.");
+        }
+        let hash = params.sha256 ?? "";
+        if (!hash && params.path) {
+          try {
+            hash = await hashFile(params.path);
+          } catch {
+            throw new Error("Could not read that file locally (check the path and permissions). Nothing was sent anywhere.");
+          }
+        }
+        try {
+          const r = await findArtifacts(hash, { engineUrl, apiKey });
+          if (!r.artifacts.length) {
+            return {
+              summary: `NOT FOUND \xB7 sha256 ${hash.slice(0, 16)}\u2026 has no anchored record in this account. If you expected a match, the file changed since anchoring.`,
+              sha256: hash,
+              artifacts: []
+            };
+          }
+          const first = r.artifacts[0];
+          return {
+            summary: `FOUND ${r.artifacts.length} record(s) \xB7 newest: ${String(first.kind)} anchored ${String(first.createdAt)} (audit seq ${String(first.auditSeq)}). Content matches the anchored hash byte for byte.`,
+            sha256: hash,
+            ...r
+          };
+        } catch (e) {
+          if (e instanceof AssessError) throw new Error(`CHECK ${e.status}: ${e.type}`);
+          throw new Error("CHECK failed: unexpected error");
+        }
+      }
+    }),
     // Upgrade funnel. Records the intent signal and returns the real-account link;
     // the anon_id travels in the URL so the engine binds past usage to the tenant.
     tool({

package/openclaw.plugin.json

@@ -3,13 +3,15 @@
   "name": "Fidacy \u2014 Payment Firewall",
   "description": "A signed, independently-verifiable verdict on every money-moving agent action. Blocks wrong/lookalike payee, over-cap, and duplicate-invoice fraud before money moves. Non-custodial, local-first, deny-by-default.",
   "icon": "https://fidacy.com/logo.png",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "contracts": {
     "tools": [
       "request_payment",
       "verify_mandate",
       "get_audit_proof",
       "assess_action",
+      "anchor_artifact",
+      "check_artifact",
       "fidacy_upgrade"
     ]
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fidacy/openclaw-plugin",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Fidacy payment firewall as a native OpenClaw plugin: signed, verifiable verdicts on every money-moving agent action, in-process (no MCP subprocess).",
   "license": "Apache-2.0",
   "homepage": "https://fidacy.com",
@@ -46,20 +46,20 @@
       "npmSpec": "@fidacy/openclaw-plugin"
     }
   },
+  "scripts": {
+    "build": "node scripts/bundle.mjs",
+    "typecheck": "tsc --noEmit"
+  },
   "engines": {
     "node": ">=20"
   },
   "devDependencies": {
+    "@fidacy/firewall": "workspace:*",
+    "@fidacy/mcp": "workspace:*",
     "@types/node": "^22.10.0",
     "esbuild": "^0.24.0",
     "openclaw": "2026.6.11",
     "typebox": "1.1.39",
-    "typescript": "^5.6.3",
-    "@fidacy/firewall": "0.1.0",
-    "@fidacy/mcp": "0.1.14"
-  },
-  "scripts": {
-    "build": "node scripts/bundle.mjs",
-    "typecheck": "tsc --noEmit"
+    "typescript": "^5.6.3"
   }
 }