witnora 0.13.2 → 0.13.4

package/dist/internal/control-client/remote-collector.js

@@ -0,0 +1,318 @@
+import { chmod, mkdir, open, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, randomUUID, sign } from "node:crypto";
+import { canonicalJson } from "./canonical.js";
+export class CustomerSourceKeyRing {
+    filePath;
+    value;
+    constructor(filePath, value) {
+        this.filePath = filePath;
+        this.value = value;
+    }
+    static async create(filePath, collectorId, keyId = `${collectorId}-${new Date().toISOString().slice(0, 10)}-${randomUUID().slice(0, 8)}`) {
+        identifier(collectorId, "collectorId");
+        identifier(keyId, "keyId");
+        const target = resolve(filePath);
+        try {
+            await readFile(target);
+            throw new Error(`Customer source key ring already exists at ${target}.`);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        const key = generatedKey(keyId, new Date().toISOString());
+        const ring = new CustomerSourceKeyRing(target, { schemaVersion: "agentcert.customer_source_keyring.v0.2", collectorId, activeKeyId: keyId, keys: [key] });
+        await ring.persist();
+        return ring;
+    }
+    static async open(filePath) {
+        const target = resolve(filePath);
+        const parsed = JSON.parse(await readFile(target, "utf8"));
+        validateRing(parsed);
+        return new CustomerSourceKeyRing(target, parsed);
+    }
+    get collectorId() { return this.value.collectorId; }
+    activeSigner() {
+        const key = this.value.keys.find((item) => item.keyId === this.value.activeKeyId && item.status === "active");
+        if (!key)
+            throw new Error("Customer source key ring has no active signing key.");
+        return { keyId: key.keyId, privateKeyPem: key.privateKeyPem, publicKeyPem: key.publicKeyPem };
+    }
+    signerFor(keyId) {
+        const key = this.value.keys.find((item) => item.keyId === keyId);
+        if (!key)
+            throw new Error(`Customer source key ${keyId} is not present in this key ring.`);
+        return { keyId: key.keyId, privateKeyPem: key.privateKeyPem, publicKeyPem: key.publicKeyPem };
+    }
+    registration(previousKeyId) {
+        const signer = this.activeSigner();
+        const previous = previousKeyId ?? [...this.value.keys].reverse().find((item) => item.status === "retired")?.keyId;
+        return { collectorId: this.collectorId, keyId: signer.keyId, publicKeyPem: signer.publicKeyPem, previousKeyId: previous };
+    }
+    async rotate(keyId = `${this.collectorId}-${new Date().toISOString().slice(0, 10)}-${randomUUID().slice(0, 8)}`) {
+        identifier(keyId, "keyId");
+        if (this.value.keys.some((item) => item.keyId === keyId))
+            throw new Error(`Customer source key ${keyId} already exists.`);
+        const now = new Date().toISOString();
+        const previousKeyId = this.value.activeKeyId;
+        this.value = {
+            ...this.value,
+            activeKeyId: keyId,
+            keys: [...this.value.keys.map((item) => item.keyId === previousKeyId ? { ...item, status: "retired", retiredAt: now } : item), generatedKey(keyId, now)],
+        };
+        await this.persist();
+        return { previousKeyId, signer: this.activeSigner() };
+    }
+    async persist() {
+        await mkdir(dirname(this.filePath), { recursive: true });
+        const temporary = `${this.filePath}.${process.pid}.${randomUUID()}.tmp`;
+        await writeFile(temporary, `${JSON.stringify(this.value, null, 2)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        await chmod(temporary, 0o600);
+        await rename(temporary, this.filePath);
+    }
+}
+export class RemoteCollectorClient {
+    baseUrl;
+    projectId;
+    apiKey;
+    requestFetch;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/$/, "");
+        this.projectId = options.projectId;
+        this.apiKey = options.apiKey;
+        this.requestFetch = options.fetch ?? fetch;
+        if (!this.baseUrl || !this.projectId || !this.apiKey)
+            throw new Error("baseUrl, projectId, and apiKey are required.");
+    }
+    registerSourceKey(input) {
+        return this.json("collector-keys", { method: "POST", body: JSON.stringify(input) });
+    }
+    append(runId, records, idempotencyKey = `record-${records[0]?.eventHash ?? randomUUID()}`) {
+        return this.json(`trusted-runs/${encodeURIComponent(runId)}/records`, {
+            method: "POST",
+            headers: { "idempotency-key": idempotencyKey },
+            body: JSON.stringify({ records }),
+        });
+    }
+    heartbeat(input) {
+        const payload = {
+            schemaVersion: "agentcert.collector_heartbeat.v0.2",
+            collectorId: input.collectorId,
+            sourceKeyId: input.signer.keyId,
+            runId: input.runId,
+            occurredAt: input.occurredAt ?? new Date().toISOString(),
+            pendingRecordCount: input.pendingRecordCount,
+            lastAckSequence: input.lastAckSequence,
+        };
+        const payloadSha256 = sha256(canonicalJson(payload));
+        return this.json("collector-heartbeats", {
+            method: "POST",
+            body: JSON.stringify({ payload, payloadSha256, signature: signSourceDigest(payloadSha256, input.signer) }),
+        });
+    }
+    reconcile(runId, receipt) {
+        return this.json(`trusted-runs/${encodeURIComponent(runId)}/reconcile`, {
+            method: "POST",
+            headers: { "idempotency-key": `reconcile-${String(receipt.receiptSha256 ?? randomUUID())}` },
+            body: JSON.stringify(receipt),
+        });
+    }
+    proposeAction(proposal, idempotencyKey) {
+        return this.json("actions", {
+            method: "POST",
+            headers: { "idempotency-key": idempotencyKey },
+            body: JSON.stringify(proposal),
+        });
+    }
+    getAction(actionId) {
+        return this.json(`actions/${encodeURIComponent(actionId)}`);
+    }
+    issueExecutionGrant(actionId, grant, idempotencyKey) {
+        return this.json(`actions/${encodeURIComponent(actionId)}/execution-grant`, {
+            method: "POST",
+            headers: { "idempotency-key": idempotencyKey },
+            body: JSON.stringify(grant),
+        });
+    }
+    status() { return this.json("collector-status"); }
+    async revokeSourceKey(keyId) {
+        return this.json(`collector-keys/${encodeURIComponent(keyId)}`, { method: "DELETE" });
+    }
+    sink() {
+        return {
+            name: "agentcert-remote-collector-v0.2",
+            write: async (record) => { await this.append(record.runId, [record], `record-${record.eventHash}`); },
+        };
+    }
+    async json(suffix, init = {}) {
+        const response = await this.requestFetch(`${this.baseUrl}/v1/projects/${encodeURIComponent(this.projectId)}/${suffix}`, {
+            ...init,
+            headers: { authorization: `Bearer ${this.apiKey}`, ...(init.body ? { "content-type": "application/json" } : {}), ...init.headers },
+        });
+        const body = await response.json().catch(() => ({}));
+        if (!response.ok)
+            throw new RemoteCollectorApiError(response.status, String(body.code ?? "remote_collector_error"), String(body.error ?? `Witnora API request failed (${response.status}).`), typeof body.recovery === "string" ? body.recovery : undefined);
+        return body;
+    }
+}
+export class DurableRemoteCollectorQueue {
+    runId;
+    journalPath;
+    ackPath;
+    replayChain = Promise.resolve();
+    constructor(directory, runId) {
+        this.runId = runId;
+        this.journalPath = resolve(directory, `${safeFileName(runId)}.remote.jsonl`);
+        this.ackPath = resolve(directory, `${safeFileName(runId)}.remote-ack.json`);
+    }
+    async enqueue(record) {
+        if (record.runId !== this.runId)
+            throw new Error("Queued record runId does not match the durable queue runId.");
+        await mkdir(dirname(this.journalPath), { recursive: true });
+        const handle = await open(this.journalPath, "a");
+        try {
+            await handle.write(`${JSON.stringify(record)}\n`);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async pending() {
+        const records = await this.all();
+        const ack = await this.readAck();
+        validateAck(records, ack);
+        return records.filter((record) => record.sequence > ack.sequence);
+    }
+    async all() {
+        let raw = "";
+        try {
+            raw = await readFile(this.journalPath, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        }
+        return raw.split(/\r?\n/).filter(Boolean).map((line, index) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                throw new Error(`Remote collector queue contains invalid JSON at line ${index + 1}.`);
+            }
+        });
+    }
+    async currentAck() {
+        const records = await this.all();
+        const ack = await this.readAck();
+        validateAck(records, ack);
+        return ack;
+    }
+    async replay(client) {
+        let result;
+        const operation = this.replayChain.then(async () => {
+            let delivered = 0;
+            let latest;
+            for (const record of await this.pending()) {
+                const response = await client.append(record.runId, [record], `record-${record.eventHash}`);
+                latest = response.ack;
+                await this.writeAck(latest);
+                delivered += 1;
+            }
+            result = { delivered, ack: latest };
+        });
+        this.replayChain = operation.catch(() => undefined);
+        await operation;
+        return result;
+    }
+    async readAck() {
+        try {
+            const value = JSON.parse(await readFile(this.ackPath, "utf8"));
+            if (!Number.isSafeInteger(value.sequence) || Number(value.sequence) < 0 || typeof value.eventHash !== "string" || !/^[a-f0-9]{64}$/.test(value.eventHash)) {
+                throw new Error("Remote collector ACK file is invalid.");
+            }
+            return { sequence: Number(value.sequence), eventHash: value.eventHash };
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return { sequence: -1 };
+            throw error;
+        }
+    }
+    async writeAck(ack) {
+        const records = await this.all();
+        validateAck(records, ack);
+        const current = await this.readAck();
+        if (current.sequence > ack.sequence)
+            return;
+        if (current.sequence === ack.sequence) {
+            if (current.eventHash !== ack.eventHash)
+                throw new Error(`Remote collector ACK hash conflicts at sequence ${ack.sequence}.`);
+            return;
+        }
+        await mkdir(dirname(this.ackPath), { recursive: true });
+        const temporary = `${this.ackPath}.${process.pid}.${randomUUID()}.tmp`;
+        await writeFile(temporary, JSON.stringify(ack), { encoding: "utf8", mode: 0o600 });
+        await rename(temporary, this.ackPath);
+    }
+}
+function validateAck(records, ack) {
+    if (ack.sequence === -1)
+        return;
+    const acknowledged = records.find((record) => record.sequence === ack.sequence);
+    if (!acknowledged || acknowledged.eventHash !== ack.eventHash) {
+        throw new Error(`Remote collector ACK does not match the local journal at sequence ${ack.sequence}.`);
+    }
+}
+export class RemoteCollectorApiError extends Error {
+    status;
+    code;
+    recovery;
+    constructor(status, code, message, recovery) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.recovery = recovery;
+        this.name = "RemoteCollectorApiError";
+    }
+}
+function generatedKey(keyId, createdAt) {
+    const { privateKey, publicKey } = generateKeyPairSync("ed25519");
+    return {
+        keyId,
+        privateKeyPem: privateKey.export({ type: "pkcs8", format: "pem" }).toString(),
+        publicKeyPem: publicKey.export({ type: "spki", format: "pem" }).toString(),
+        createdAt,
+        status: "active",
+    };
+}
+function signSourceDigest(digest, signer) {
+    if (!/^[a-f0-9]{64}$/.test(digest))
+        throw new Error("A SHA-256 digest is required for source signing.");
+    return { algorithm: "Ed25519", keyId: signer.keyId, signature: sign(null, Buffer.from(digest, "hex"), createPrivateKey(signer.privateKeyPem)).toString("base64url") };
+}
+function validateRing(value) {
+    if (value.schemaVersion !== "agentcert.customer_source_keyring.v0.2")
+        throw new Error("Customer source key ring schemaVersion is not supported.");
+    identifier(value.collectorId, "collectorId");
+    identifier(value.activeKeyId, "activeKeyId");
+    if (!Array.isArray(value.keys) || value.keys.length === 0)
+        throw new Error("Customer source key ring has no keys.");
+    for (const key of value.keys) {
+        identifier(key.keyId, "keys[].keyId");
+        const privateKey = createPrivateKey(key.privateKeyPem);
+        const derivedPublic = createPublicKey(privateKey).export({ type: "spki", format: "pem" }).toString();
+        if (privateKey.asymmetricKeyType !== "ed25519" || derivedPublic !== createPublicKey(key.publicKeyPem).export({ type: "spki", format: "pem" }).toString()) {
+            throw new Error(`Customer source key ${key.keyId} is invalid.`);
+        }
+    }
+}
+function sha256(value) { return createHash("sha256").update(value).digest("hex"); }
+function identifier(value, field) {
+    if (!value || value.length > 160 || !/^[A-Za-z0-9._:-]+$/.test(value))
+        throw new Error(`${field} must use 1 to 160 URL-safe identifier characters.`);
+    return value;
+}
+function safeFileName(value) { return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 160); }

package/dist/onboarding-templates.js

@@ -131,7 +131,7 @@ export function starterInstructions(template, subject) {
         return `
 Next:
   1. Edit tripwire.yml so startUrl and agent.command/agent.args match your app and browser agent.
-  2. Run in CI with Kakarottoooo/agentcert/actions/tripwire@v0, or re-run init with --github-action.
+  2. Run in CI with Kakarottoooo/witnora/actions/tripwire@v0, or re-run init with --github-action.
   3. Run: npx witnora@latest run --tripwire .tripwire/latest/tripwire-result.json --subject ${JSON.stringify(subject)} --fail-on-verdict --push
 `;
     if (template === "mcp")
@@ -203,7 +203,7 @@ jobs:
         with:
           node-version: "20"
       - id: agentcert
-        uses: Kakarottoooo/agentcert/actions/tripwire@v0
+        uses: Kakarottoooo/witnora/actions/tripwire@v0
         with:
           config: tripwire.yml
           out: .tripwire/latest

package/dist/probe-process.js

@@ -0,0 +1,135 @@
+import { spawn } from "node:child_process";
+export async function inspectIsolatedOutcomeProbe(config) {
+    const result = await invokeProbeChild({ mode: "health", config });
+    if (result.ready !== true)
+        throw new Error("Independent outcome-probe child did not become ready.");
+}
+export async function observeInIsolatedOutcomeProbe(config, input) {
+    const result = await invokeProbeChild({ mode: "observe", config, input });
+    if (!result.observation || typeof result.observation !== "object" || Array.isArray(result.observation))
+        throw new Error("Independent outcome-probe child returned no bounded observation.");
+    return result.observation;
+}
+async function invokeProbeChild(request) {
+    const serializedRequest = `${JSON.stringify(request)}\n`;
+    if (Buffer.byteLength(serializedRequest) > 262_144)
+        throw new Error("Independent outcome-probe input exceeded its bounded input limit.");
+    const child = spawn(process.execPath, ["--input-type=module", "--eval", PROBE_CHILD_SOURCE], {
+        env: {}, windowsHide: true, stdio: ["pipe", "pipe", "pipe"],
+    });
+    const stdout = [];
+    const stderr = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    child.stdout.on("data", (chunk) => {
+        stdoutBytes += chunk.length;
+        if (stdoutBytes <= 65_536)
+            stdout.push(chunk);
+        else
+            child.kill();
+    });
+    child.stderr.on("data", (chunk) => {
+        stderrBytes += chunk.length;
+        if (stderrBytes <= 8_192)
+            stderr.push(chunk);
+    });
+    const timeout = setTimeout(() => child.kill(), 10_000);
+    child.stdin.end(serializedRequest);
+    const exitCode = await new Promise((resolveExit, reject) => {
+        child.once("error", reject);
+        child.once("close", resolveExit);
+    }).finally(() => clearTimeout(timeout));
+    if (stdoutBytes > 65_536)
+        throw new Error("Independent outcome-probe child exceeded its bounded output limit.");
+    const output = Buffer.concat(stdout).toString("utf8");
+    let value;
+    try {
+        value = JSON.parse(output);
+    }
+    catch {
+        throw new Error(`Independent outcome-probe child failed (${exitCode ?? "unknown"}): ${Buffer.concat(stderr).toString("utf8").slice(0, 500) || "invalid response"}`);
+    }
+    if (exitCode !== 0 || value.ok !== true)
+        throw new Error(`Independent outcome-probe child failed: ${String(value.error ?? "unknown error")}`);
+    return value;
+}
+const PROBE_CHILD_SOURCE = String.raw `
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+
+const chunks = [];
+let bytes = 0;
+for await (const chunk of process.stdin) {
+  bytes += chunk.length;
+  if (bytes > 262144) throw new Error("probe_input_too_large");
+  chunks.push(chunk);
+}
+
+try {
+  const request = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  const config = request.config ?? {};
+  const moduleBytes = await readFile(config.modulePath);
+  const digest = createHash("sha256").update(moduleBytes).digest("hex");
+  if (digest !== config.moduleSha256) throw new Error("probe_module_digest_mismatch");
+  const loaded = await import(pathToFileURL(config.modulePath).href + "?sha256=" + digest);
+  if (typeof loaded.createWitnoraOutcomeProbe !== "function") throw new Error("probe_factory_missing");
+  const context = Object.freeze({
+    probeId: config.probeId,
+    projectId: config.projectId,
+    targetReadCredential: Object.freeze({ handle: config.credentialHandle, access: "READ_ONLY" }),
+  });
+  const probe = await loaded.createWitnoraOutcomeProbe(context);
+  if (probe?.id !== config.probeId || probe?.credentialHandle !== config.credentialHandle || probe?.readOnly !== true || typeof probe?.observe !== "function") throw new Error("probe_contract_mismatch");
+  if (request.mode === "health") {
+    respond({ ok: true, ready: true });
+  } else if (request.mode === "observe") {
+    const raw = await probe.observe(request.input ?? {});
+    const observedState = record(raw?.observedState, "observedState");
+    rejectSecrets(observedState);
+    const allowedMethods = new Set(["TARGET_API", "TARGET_UI", "TARGET_AUDIT_LOG", "WEBHOOK", "DATABASE_QUERY", "THIRD_PARTY_CONFIRMATION"]);
+    if (!allowedMethods.has(raw?.observationMethod) || raw?.observationSource !== config.probeId) throw new Error("probe_observation_binding_invalid");
+    const references = raw.evidenceReferences === undefined ? undefined : strings(raw.evidenceReferences, 20);
+    const confidence = raw.confidence === undefined ? undefined : Number(raw.confidence);
+    if (confidence !== undefined && (!Number.isFinite(confidence) || confidence < 0 || confidence > 1)) throw new Error("probe_confidence_invalid");
+    respond({ ok: true, observation: {
+      observedState,
+      observationMethod: raw.observationMethod,
+      observationSource: raw.observationSource,
+      ...(references ? { evidenceReferences: references } : {}),
+      ...(confidence === undefined ? {} : { confidence }),
+    } });
+  } else {
+    throw new Error("probe_mode_invalid");
+  }
+} catch (error) {
+  respond({ ok: false, error: error instanceof Error ? error.message.slice(0, 200) : "probe_failed" }, 1);
+}
+
+function record(value, name) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(name + "_invalid");
+  return value;
+}
+function strings(value, maximum) {
+  if (!Array.isArray(value) || value.length > maximum || value.some((item) => typeof item !== "string" || item.length > 512)) throw new Error("probe_evidence_references_invalid");
+  return value;
+}
+function rejectSecrets(value, depth = 0) {
+  if (depth > 8) throw new Error("probe_observation_too_deep");
+  for (const [key, child] of Object.entries(value)) {
+    if (/(authorization|cookie|password|secret|token|credential|api.?key|private.?key)/i.test(key)) throw new Error("probe_observation_contains_secret_field");
+    if (typeof child === "string" && child.length > 4096) throw new Error("probe_observation_string_too_large");
+    if (child && typeof child === "object") rejectSecrets(child, depth + 1);
+  }
+}
+function respond(value, code = 0) {
+  const output = JSON.stringify(value);
+  if (Buffer.byteLength(output) > 65536) {
+    process.stdout.write(JSON.stringify({ ok: false, error: "probe_output_too_large" }));
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(output);
+  process.exitCode = code;
+}
+`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "witnora",
-  "version": "0.13.2",
+  "version": "0.13.4",
   "description": "Independent assurance for covered agent action paths across models and frameworks.",
   "type": "module",
   "license": "Apache-2.0",
@@ -41,8 +41,8 @@
       "import": "./dist/vendor/onegent-runtime/browser-adapter-kit.js"
     },
     "./deployment-enforcement": {
-      "types": "./dist/vendor/agentcert-sdk/deployment-enforcement.d.ts",
-      "import": "./dist/vendor/agentcert-sdk/deployment-enforcement.js"
+      "types": "./dist/internal/control-client/deployment-enforcement.d.ts",
+      "import": "./dist/internal/control-client/deployment-enforcement.js"
     }
   },
   "files": [
@@ -66,8 +66,5 @@
   },
   "optionalDependencies": {
     "pg": "^8.16.3"
-  },
-  "dependencies": {
-    "agentcert-sdk": "0.5.0"
   }
 }