@forestrie/mcp-register 0.0.0-stage → 0.1.0

package/dist/node/signer-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer-file.d.ts","sourceRoot":"","sources":["../../src/node/signer-file.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,IAAI,EAAG,oBAAoB,CAAU;CAC/C;AAED,gGAAgG;AAChG,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,CAI5E;AAkED;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG,KAAK,GAAG,WAAW,CAAC;AAkB1C,MAAM,WAAW,aAAc,SAAQ,WAAW;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GACjD,OAAO,CAAC,aAAa,CAAC,CA8ExB;AAQD,oFAAoF;AACpF,wBAAgB,YAAY,CAAC,EAAE,EAAE,UAAU,GAAG,MAAM,CAInD"}

package/dist/node/signer-file.js

@@ -0,0 +1,183 @@
+/**
+ * The default signer backend: an ES256 (P-256) private key in a local JWK
+ * file, created on first use.
+ *
+ * Proportionate custody for what the key can do: it owns one data log
+ * whose grant someone else issued and bounded, and it holds no funds. The
+ * file is written once, `0600` in a `0700` directory, atomically (written
+ * aside, then hard-linked into place), so two servers starting together
+ * cannot both write one and neither can read a half-written one. It is
+ * never overwritten: a key that signed a grant's `grantData` must not
+ * silently change under it.
+ *
+ * The private key is imported non-extractable for signing; nothing in this
+ * package reads the `d` field again after import, and no tool result or
+ * log line carries it.
+ */
+import { webcrypto } from "node:crypto";
+import { linkSync, lstatSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const subtle = webcrypto.subtle;
+export class KeyFileError extends Error {
+    code = "signer_unavailable";
+}
+/** `$MCP_REGISTER_HOME`, else `$XDG_CONFIG_HOME/forestrie/mcp-register`, else `~/.config/…`. */
+export function registerHome(env) {
+    if (env["MCP_REGISTER_HOME"])
+        return env["MCP_REGISTER_HOME"];
+    const config = env["XDG_CONFIG_HOME"] ?? join(homedir(), ".config");
+    return join(config, "forestrie", "mcp-register");
+}
+function b64urlToBytes(s) {
+    return new Uint8Array(Buffer.from(s, "base64url"));
+}
+function isP256PrivateJwk(v) {
+    const j = v;
+    return (typeof v === "object" &&
+        v !== null &&
+        j.kty === "EC" &&
+        j.crv === "P-256" &&
+        typeof j.x === "string" &&
+        typeof j.y === "string" &&
+        typeof j.d === "string");
+}
+/**
+ * Write a new key without ever exposing a half-written file: the JWK goes
+ * to a private temporary file first, then is hard-linked into place, which
+ * fails (EEXIST) if another process got there first, in which case its key
+ * is used. The temporary file is always removed.
+ */
+async function createKeyFile(path, note) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const pair = (await subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, true, ["sign", "verify"]));
+    const jwk = await subtle.exportKey("jwk", pair.privateKey);
+    const record = {
+        kty: jwk.kty,
+        crv: jwk.crv,
+        x: jwk.x,
+        y: jwk.y,
+        d: jwk.d,
+        use: "sig",
+        alg: "ES256",
+        note,
+    };
+    const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        writeFileSync(tmp, JSON.stringify(record, null, 2) + "\n", {
+            flag: "wx",
+            mode: 0o600,
+        });
+        try {
+            linkSync(tmp, path);
+        }
+        catch (err) {
+            // Lost a race to another process creating the same file: use theirs.
+            if (err.code !== "EEXIST")
+                throw err;
+        }
+    }
+    finally {
+        try {
+            unlinkSync(tmp);
+        }
+        catch {
+            // already gone
+        }
+    }
+}
+const KEY_ROLES = {
+    log: {
+        label: "log key",
+        note: "Forestrie log key for @forestrie/mcp-register. Grants name its public x‖y; keep this file private.",
+        createdBy: "get_log_key or register_statement",
+    },
+    authority: {
+        label: "authority key",
+        note: "Forestrie authority key for @forestrie/mcp-register: owns the requester's authority log and signs the child grants issue_grant makes. Keep this file private.",
+        createdBy: 'get_log_key with which: "authority", or issue_grant,',
+    },
+};
+/**
+ * Load the key at `path`. Lazy by design: the server opens the signer at the
+ * first tool call that needs it, so starting the server never writes a
+ * file. With `create` (the default) a missing key is created; without it a
+ * missing key is a `KeyFileError`, so a read-only tool never makes one.
+ *
+ * Refused, like ssh refuses a loose private key: a key path that is a
+ * symlink, or a key file readable or writable by group or others.
+ */
+export async function openKeyFileSigner(path, options = {}) {
+    const role = options.role ?? "log";
+    const label = KEY_ROLES[role].label;
+    let created = false;
+    let stat = lstatOrUndefined(path);
+    if (stat === undefined) {
+        if (options.create === false)
+            throw new KeyFileError(`no ${label} at ${path} yet: ${KEY_ROLES[role].createdBy} creates it`);
+        try {
+            await createKeyFile(path, KEY_ROLES[role].note);
+        }
+        catch (err) {
+            throw new KeyFileError(`cannot create the ${label} file ${path}: ${err.message}`);
+        }
+        created = true;
+        stat = lstatOrUndefined(path);
+    }
+    if (stat === undefined || stat.isSymbolicLink() || !stat.isFile())
+        throw new KeyFileError(`the ${label} path ${path} is not a regular file (a symlink or directory is refused)`);
+    if ((stat.mode & 0o077) !== 0)
+        throw new KeyFileError(`the ${label} file ${path} is accessible to other users (mode ${(stat.mode & 0o777).toString(8)}); chmod 600 it`);
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (err) {
+        throw new KeyFileError(`cannot read the ${label} file ${path}: ${err.message}`);
+    }
+    let jwk;
+    try {
+        jwk = JSON.parse(text);
+    }
+    catch {
+        throw new KeyFileError(`the ${label} file ${path} is not JSON`);
+    }
+    if (!isP256PrivateJwk(jwk))
+        throw new KeyFileError(`the ${label} file ${path} is not a P-256 private JWK (kty EC, crv P-256, x, y, d)`);
+    let privateKey;
+    try {
+        privateKey = await subtle.importKey("jwk", { kty: "EC", crv: "P-256", x: jwk.x, y: jwk.y, d: jwk.d, ext: false }, { name: "ECDSA", namedCurve: "P-256" }, false, ["sign"]);
+    }
+    catch {
+        throw new KeyFileError(`the ${label} file ${path} holds an invalid P-256 key`);
+    }
+    const xy = new Uint8Array(64);
+    xy.set(b64urlToBytes(jwk.x), 0);
+    xy.set(b64urlToBytes(jwk.y), 32);
+    return {
+        path,
+        created,
+        description: `local ${label} file ${path}`,
+        publicKeyXY: async () => xy.slice(),
+        sign: async (message) => new Uint8Array(await subtle.sign({ name: "ECDSA", hash: "SHA-256" }, privateKey, message)),
+    };
+}
+/** SubjectPublicKeyInfo DER prefix for an uncompressed P-256 point. */
+const P256_SPKI_PREFIX = Buffer.from("3059301306072a8648ce3d020106082a8648ce3d030107034200", "hex");
+/** The public key as an SPKI PEM, the form forestrie-cli's `--signer-pem` reads. */
+export function publicKeyPem(xy) {
+    const der = Buffer.concat([P256_SPKI_PREFIX, Buffer.from([0x04]), xy]);
+    const b64 = der.toString("base64").replace(/(.{64})/g, "$1\n");
+    return `-----BEGIN PUBLIC KEY-----\n${b64}\n-----END PUBLIC KEY-----\n`;
+}
+function lstatOrUndefined(path) {
+    try {
+        return lstatSync(path);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw new KeyFileError(`cannot stat the key path ${path}: ${err.message}`);
+    }
+}
+//# sourceMappingURL=signer-file.js.map

package/dist/node/signer-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer-file.js","sourceRoot":"","sources":["../../src/node/signer-file.ts"],"names":[],"mappings":"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"}

package/dist/node/store.d.ts

@@ -0,0 +1,40 @@
+export interface RegistrationRecord {
+    contentHash: string;
+    /** "signed": saved, not (yet) known to be accepted. "accepted": canopy answered 303. */
+    state: "signed" | "accepted";
+    /** From canopy's 303; absent until accepted. */
+    statusUrl?: string;
+    baseUrl: string;
+    rootLogId: string;
+    logId: string;
+    contentType: string;
+    issuer: string;
+    subject: string;
+    signedAt: string;
+    acceptedAt?: string;
+    /** When check_registration first saw it pending; bounds the wait. */
+    firstPendingAt?: string;
+    entryId?: string;
+    massifHeight?: number;
+    receiptUrl?: string;
+    sealedAt?: string;
+}
+export declare class StoreError extends Error {
+    readonly code: "unknown_registration" | "corrupt_record" | "store_failed";
+    constructor(code: "unknown_registration" | "corrupt_record" | "store_failed", message: string);
+}
+export declare class RegistrationStore {
+    readonly root: string;
+    constructor(root: string);
+    dir(contentHash: string): string;
+    statementPath(contentHash: string): string;
+    receiptPath(contentHash: string): string;
+    saveStatement(record: RegistrationRecord, statement: Uint8Array): void;
+    saveRecord(record: RegistrationRecord): void;
+    saveReceipt(contentHash: string, receipt: Uint8Array): void;
+    load(contentHash: string): RegistrationRecord;
+    readStatement(contentHash: string): Uint8Array;
+    /** The saved receipt, or `undefined` when there is none yet. */
+    readReceipt(contentHash: string): Uint8Array | undefined;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/node/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/node/store.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,wFAAwF;IACxF,KAAK,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC7B,gDAAgD;IAChD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,UAAW,SAAQ,KAAK;IAEjC,QAAQ,CAAC,IAAI,EAAE,sBAAsB,GAAG,gBAAgB,GAAG,cAAc;gBAAhE,IAAI,EAAE,sBAAsB,GAAG,gBAAgB,GAAG,cAAc,EACzE,OAAO,EAAE,MAAM;CAIlB;AAgCD,qBAAa,iBAAiB;IAChB,QAAQ,CAAC,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM;IAEjC,GAAG,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM;IAShC,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM;IAI1C,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM;IAIxC,aAAa,CAAC,MAAM,EAAE,kBAAkB,EAAE,SAAS,EAAE,UAAU,GAAG,IAAI;IAWtE,UAAU,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI;IAS5C,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI;IAM3D,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,kBAAkB;IA8B7C,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,UAAU;IAO9C,gEAAgE;IAChE,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;CAWzD"}

package/dist/node/store.js

@@ -0,0 +1,117 @@
+/**
+ * Where registrations are kept between tool calls:
+ * `<home>/registrations/<contentHash>/{record.json, statement.cose, receipt.cose}`.
+ *
+ * The statement and receipt live on disk so tools can hand back paths
+ * rather than megabytes of base64, and so `@forestrie/mcp-verify` (which
+ * takes `{path}` inputs) can be pointed straight at them. The record is
+ * the caller's evidence of what was registered where; nothing here is
+ * secret.
+ *
+ * The signed statement is saved BEFORE it is sent (`state: "signed"`), so a
+ * failure after canopy has accepted it never loses the handle: the status
+ * URL is derived from the content hash, and check_registration can still
+ * find it. Every filesystem failure is a `StoreError` with a code.
+ */
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export class StoreError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+const HASH = /^[0-9a-f]{64}$/;
+function io(what, run) {
+    try {
+        return run();
+    }
+    catch (err) {
+        throw new StoreError("store_failed", `${what}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function isRecord(v) {
+    const r = v;
+    return (typeof r === "object" &&
+        r !== null &&
+        typeof r.contentHash === "string" &&
+        HASH.test(r.contentHash) &&
+        (r.state === "signed" || r.state === "accepted") &&
+        typeof r.baseUrl === "string" &&
+        typeof r.rootLogId === "string" &&
+        typeof r.logId === "string" &&
+        (r.statusUrl === undefined || typeof r.statusUrl === "string") &&
+        (r.receiptUrl === undefined || typeof r.receiptUrl === "string") &&
+        (r.entryId === undefined || /^[0-9a-f]{32}$/.test(r.entryId)));
+}
+export class RegistrationStore {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    dir(contentHash) {
+        if (!HASH.test(contentHash))
+            throw new StoreError("unknown_registration", `contentHash must be 64 lowercase hex characters (the sha256 register_statement returned)`);
+        return join(this.root, "registrations", contentHash);
+    }
+    statementPath(contentHash) {
+        return join(this.dir(contentHash), "statement.cose");
+    }
+    receiptPath(contentHash) {
+        return join(this.dir(contentHash), "receipt.cose");
+    }
+    saveStatement(record, statement) {
+        io(`cannot save the signed statement under ${this.root}`, () => {
+            mkdirSync(this.dir(record.contentHash), {
+                recursive: true,
+                mode: 0o700,
+            });
+            writeFileSync(this.statementPath(record.contentHash), statement);
+        });
+        this.saveRecord(record);
+    }
+    saveRecord(record) {
+        io(`cannot save the registration record under ${this.root}`, () => writeFileSync(join(this.dir(record.contentHash), "record.json"), JSON.stringify(record, null, 2) + "\n"));
+    }
+    saveReceipt(contentHash, receipt) {
+        io(`cannot save the receipt under ${this.root}`, () => writeFileSync(this.receiptPath(contentHash), receipt));
+    }
+    load(contentHash) {
+        const path = join(this.dir(contentHash), "record.json");
+        let text;
+        try {
+            text = readFileSync(path, "utf8");
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                throw new StoreError("unknown_registration", `no registration ${contentHash} in ${this.root}: register_statement records each registration there`);
+            throw new StoreError("store_failed", `cannot read ${path}: ${err.message}`);
+        }
+        let record;
+        try {
+            record = JSON.parse(text);
+        }
+        catch {
+            record = undefined;
+        }
+        if (!isRecord(record) || record.contentHash !== contentHash)
+            throw new StoreError("corrupt_record", `${path} is not a registration record for ${contentHash}`);
+        return record;
+    }
+    readStatement(contentHash) {
+        return io(`cannot read the signed statement for ${contentHash}`, () => new Uint8Array(readFileSync(this.statementPath(contentHash))));
+    }
+    /** The saved receipt, or `undefined` when there is none yet. */
+    readReceipt(contentHash) {
+        try {
+            return new Uint8Array(readFileSync(this.receiptPath(contentHash)));
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return undefined;
+            throw new StoreError("store_failed", `cannot read the receipt for ${contentHash}: ${err.message}`);
+        }
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/node/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../../src/node/store.ts"],"names":[],"mappings":"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"}

package/dist/node/text.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Outward-facing text for the MCP adapter: the server `instructions`, the
+ * per-tool titles and descriptions, and the prompts. Change the wording on
+ * purpose, never in passing.
+ */
+export declare const INSTRUCTIONS = "@forestrie/mcp-register is the write path of the Forestrie MCP trio. It signs statements with a log key it holds (ES256, behind a signer backend; by default a local key file it creates), registers them on a Forestrie transparency log under a Forestrie-Grant, delegates sealing for your data log, and checks the receipt with @forestrie/mcp-verify's verifier through @forestrie/mcp-resolve.\n\nIt can also act as a requester that is its own grant issuer: issue_grant signs a child grant with a separate authority key, and register_grant registers it with canopy, paying canopy's x402 402 from a configured payer within hard caps, or handing you the payment requirements to pay from your own wallet (relay mode). Forestrie runs no grant issuer.\n\nYou never handle signature bytes or keys: you pass the payload, the server signs; the payer key never crosses this boundary, and the spending caps are configuration, not arguments.\n\nThe loop with a grant you hold: get_log_key \u2192 delegate_sealing once per log \u2192 register_statement \u2192 check_registration until sealed \u2192 verify_registration (the \"register\" prompt). Buying the grant first: issue_grant \u2192 register_grant until complete (the \"issue-and-pay\" prompt). The \"audit\" prompt explains what a verified receipt does and does not prove.\n\nConfiguration, each overridable per call: FORESTRIE_BASE_URL (the canopy SCRAPI base URL), FORESTRIE_ROOT_LOG_ID (the forest's root log id, R), FORESTRIE_GRANT (the grant, as base64 or a file path), FORESTRIE_AUTHORITY_GRANT (your authority log's grant, for issue_grant), FORESTRIE_COORDINATOR_URL and FORESTRIE_KNOWN_SEALER_KEY (for delegate_sealing; the operator publishes both). Payment, never overridable per call: MCP_REGISTER_PAYER_KEY_FILE and the MCP_REGISTER_PAY_* caps. MCP_REGISTER_HOME holds the key files, the grants, the registrations and the spend ledger.";
+/** Tool names, in registration order — the one list `server.ts` registers
+ *  from and `cli.ts`'s `--help` prints, so the two cannot drift.
+ *  `test/node/help.test.ts` asserts `--help` names exactly what `tools/list`
+ *  returns. */
+export declare const TOOL_NAMES: readonly ["get_log_key", "register_statement", "check_registration", "verify_registration", "delegate_sealing", "issue_grant", "register_grant"];
+export type ToolName = (typeof TOOL_NAMES)[number];
+export declare const TOOL_TITLES: Record<ToolName, string>;
+export declare const TOOL_DESCRIPTIONS: Record<ToolName, string>;
+/** Prompt names, in registration order. */
+export declare const PROMPT_NAMES: readonly ["register", "audit", "issue-and-pay"];
+export type PromptName = (typeof PROMPT_NAMES)[number];
+export declare const PROMPT_TITLES: Record<PromptName, string>;
+export declare const PROMPT_DESCRIPTIONS: Record<PromptName, string>;
+export declare function registerPromptText(args: {
+    what?: string | undefined;
+}): string;
+export declare function auditPromptText(args: {
+    contentHash?: string | undefined;
+}): string;
+export declare function issueAndPayPromptText(args: {
+    purpose?: string | undefined;
+}): string;
+//# sourceMappingURL=text.d.ts.map

package/dist/node/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/node/text.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,YAAY,m2DAQkiB,CAAC;AAE5jB;;;eAGe;AACf,eAAO,MAAM,UAAU,kJAQb,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnD,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAQhD,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAetD,CAAC;AAEF,2CAA2C;AAC3C,eAAO,MAAM,YAAY,iDAAkD,CAAC;AAE5E,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAIpD,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAO1D,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B,GAAG,MAAM,CAmBT;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC,GAAG,MAAM,CAgBT;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B,GAAG,MAAM,CA4BT"}

package/dist/node/text.js

@@ -0,0 +1,124 @@
+/**
+ * Outward-facing text for the MCP adapter: the server `instructions`, the
+ * per-tool titles and descriptions, and the prompts. Change the wording on
+ * purpose, never in passing.
+ */
+export const INSTRUCTIONS = `@forestrie/mcp-register is the write path of the Forestrie MCP trio. It signs statements with a log key it holds (ES256, behind a signer backend; by default a local key file it creates), registers them on a Forestrie transparency log under a Forestrie-Grant, delegates sealing for your data log, and checks the receipt with @forestrie/mcp-verify's verifier through @forestrie/mcp-resolve.
+
+It can also act as a requester that is its own grant issuer: issue_grant signs a child grant with a separate authority key, and register_grant registers it with canopy, paying canopy's x402 402 from a configured payer within hard caps, or handing you the payment requirements to pay from your own wallet (relay mode). Forestrie runs no grant issuer.
+
+You never handle signature bytes or keys: you pass the payload, the server signs; the payer key never crosses this boundary, and the spending caps are configuration, not arguments.
+
+The loop with a grant you hold: get_log_key → delegate_sealing once per log → register_statement → check_registration until sealed → verify_registration (the "register" prompt). Buying the grant first: issue_grant → register_grant until complete (the "issue-and-pay" prompt). The "audit" prompt explains what a verified receipt does and does not prove.
+
+Configuration, each overridable per call: FORESTRIE_BASE_URL (the canopy SCRAPI base URL), FORESTRIE_ROOT_LOG_ID (the forest's root log id, R), FORESTRIE_GRANT (the grant, as base64 or a file path), FORESTRIE_AUTHORITY_GRANT (your authority log's grant, for issue_grant), FORESTRIE_COORDINATOR_URL and FORESTRIE_KNOWN_SEALER_KEY (for delegate_sealing; the operator publishes both). Payment, never overridable per call: MCP_REGISTER_PAYER_KEY_FILE and the MCP_REGISTER_PAY_* caps. MCP_REGISTER_HOME holds the key files, the grants, the registrations and the spend ledger.`;
+/** Tool names, in registration order — the one list `server.ts` registers
+ *  from and `cli.ts`'s `--help` prints, so the two cannot drift.
+ *  `test/node/help.test.ts` asserts `--help` names exactly what `tools/list`
+ *  returns. */
+export const TOOL_NAMES = [
+    "get_log_key",
+    "register_statement",
+    "check_registration",
+    "verify_registration",
+    "delegate_sealing",
+    "issue_grant",
+    "register_grant",
+];
+export const TOOL_TITLES = {
+    get_log_key: "Get the log key",
+    register_statement: "Sign and register a statement",
+    check_registration: "Check a registration",
+    verify_registration: "Verify a registration's receipt",
+    delegate_sealing: "Delegate sealing for your log",
+    issue_grant: "Issue a child grant as the requester",
+    register_grant: "Register a child grant, paying if canopy asks",
+};
+export const TOOL_DESCRIPTIONS = {
+    get_log_key: 'Return the public half of one of this server\'s keys (ES256, 64 bytes x‖y, as hex, base64 and an SPKI PEM) and where it lives, creating it on first use. which: "log" (the default) is the key that owns your data log: a grant issuer names it in the grant\'s grantData, and a grant naming any other key cannot carry statements this server signs. which: "authority" is the requester\'s key that owns your authority log and signs the grants issue_grant makes. Never returns private key material.',
+    register_statement: "Sign a payload with the log key and register it under your Forestrie-Grant. Takes the payload bytes (inline base64 or a file path, up to canopy's 4 MiB statement limit) and its content type. The signed statement is saved before it is sent, so the returned content hash always names it, even if the request fails. A payload path may not point at the log key or inside this server's home. Registration is accepted, not yet sequenced: call check_registration next.",
+    check_registration: "One status check for a registration, by its content hash: pending (not yet sequenced; retry after the given seconds), awaiting_seal (sequenced, entry id known, receipt not yet sealed — sealing takes minutes, and never happens until delegate_sealing has run for the log), or sealed (the receipt is saved and its path returned). Any other answer from canopy is reported as a problem with its reason. canopy answers a statement it never received exactly like a pending one, so after ten minutes of pending this says so. Does not sleep; pace the retries yourself.",
+    verify_registration: "Verify a sealed registration's receipt over the statement you registered, with @forestrie/mcp-verify's verifier, and return its four-question answers unaltered. By default the trust root is this server's own log key, the root of your data log; verifying never creates a key. Pass a known accumulator (from @forestrie/mcp-resolve's fetch_accumulator) to use a root that can also answer split-view.",
+    delegate_sealing: "Authorise the operator's sealer to publish checkpoints for your data log, signed with the log key. Without it entries sequence but are never sealed. If the coordinator has not learned the log's public root, this calls canopy's prepare with the same grant first. Run once per log; the delegation lasts until the returned expiresAt. With as: \"authority\" it does the same for your authority log, signed with the authority key, so the child grants you register there get sealed.",
+    issue_grant: "As the requester, sign a child grant with this server's authority key: a data-log creation grant under your authority log (named by your authority grant, FORESTRIE_AUTHORITY_GRANT), naming the performer's log key (by default this server's own) and sized with maxHeight, the batch ceiling canopy prices it by. Saves the grant under a fresh child log id; nothing is sent. Call register_grant next.",
+    register_grant: "Register a child grant with canopy (POST /register/{R}/grants, your authority grant as the parent) and follow it to its receipt; call it again with the same logId to resume until it reports complete. If canopy answers 402 and a payer is configured, it pays within the server's hard caps (per call, per UTC day, one network and asset, testnet only by default) and reports any cap that refuses. With no payer it returns the payment requirements: pay them from your own x402 wallet and call again with payment set to the X-PAYMENT value. Every payment for a grant carries a nonce derived from that grant, so retries and overlapping calls can never pay for it twice. When complete it returns the completed grant for delegate_sealing and register_statement.",
+};
+/** Prompt names, in registration order. */
+export const PROMPT_NAMES = ["register", "audit", "issue-and-pay"];
+export const PROMPT_TITLES = {
+    register: "Register a statement and keep the receipt",
+    audit: "Audit a receipt: trust roots and the four questions",
+    "issue-and-pay": "Issue a child grant and pay to register it",
+};
+export const PROMPT_DESCRIPTIONS = {
+    register: "Walk through checking the key and grant, delegating sealing, registering, waiting for the seal, verifying and keeping the receipt.",
+    audit: "Explain which of the four trust questions a receipt answers under each trust root, and how to choose a root.",
+    "issue-and-pay": "As the requester, size and sign a child grant, register it with canopy, pay its 402 within the caps or relay the payment, and hand the completed grant to the performer.",
+};
+export function registerPromptText(args) {
+    const subject = args.what?.trim()
+        ? `The statement to register: ${args.what.trim()}.`
+        : "If it is not already clear what is to be registered, ask.";
+    return `Register a statement on a Forestrie transparency log with the @forestrie/mcp-register tools, and keep a receipt anyone can verify later. ${subject}
+
+You never handle signature bytes. Pass the payload; the server signs with its log key.
+
+1. Key and grant. Call get_log_key. The grant you register under must name exactly that key (its grantData is the 64-byte x‖y get_log_key returns) and must be for a data log. If you do not hold such a grant and you own an authority log yourself, buy one with the issue-and-pay prompt. Otherwise stop: give the public key to the grant issuer for your log (the owner of the authority log above it) and ask for one. Forestrie issues no grants itself.
+
+2. Sealing, once per log. Call delegate_sealing. It authorises the operator's sealer for your data log; if the coordinator never learned the log's public root it runs canopy's prepare with the same grant first. Without it entries are sequenced but never sealed, and check_registration stays at awaiting_seal. If it reports a problem, report its stage and message; do not retry in a loop.
+
+3. Register. Call register_statement with the payload and an accurate content type (application/json, text/plain, application/octet-stream, …). The signed statement may be up to 4 MiB. For anything larger, register a small manifest instead: a JSON document naming the artefact, its size and its sha-256 digest. The receipt then commits to the digest, and the artefact can live anywhere.
+
+4. Wait. Call check_registration with the content hash. pending: wait the suggested seconds and check again. awaiting_seal: the entry is sequenced; sealing typically takes minutes, so check about once a minute. sealed: the receipt is saved and its path returned.
+
+5. Verify. Call verify_registration and report every one of the four answers exactly as returned, with the trust root it used. For what each root can and cannot answer, use the audit prompt.
+
+6. Keep. Tell the user the content hash, the entry id, and the paths of the signed statement and the receipt. With a trust root, those let anyone re-verify offline with @forestrie/mcp-verify, without this server or Forestrie.`;
+}
+export function auditPromptText(args) {
+    const which = args.contentHash?.trim()
+        ? `The registration to audit: content hash ${args.contentHash.trim()}.`
+        : "Audit the registration the user names, or ask which.";
+    return `Audit a Forestrie receipt: report which of the four trust questions it answers, and under which trust root. ${which}
+
+The verifier (@forestrie/mcp-verify) answers four questions — sealing, split-view, append-authority and attribution — each ok, failed, or not_answered_by_this_root. A trust root is what you take on faith, and each root answers some questions and not others. The roots are not ranked: "not answered by this root" is a real answer, not a failure, and it must reach the user.
+
+Choosing a root:
+- Your own log key (verify_registration's default). You hold the root of your data log, so this checks the receipt against the key that delegated its sealing. Like any signature root, it cannot see a split view: it cannot tell you that others are shown the same log.
+- A known accumulator: a snapshot of the log's peaks read from the chain the forest is anchored to, which the operator does not control. Get one with @forestrie/mcp-resolve's fetch_accumulator (you need your own RPC access) and pass it to verify_registration, or let @forestrie/mcp-resolve's verify_fetched_receipt read and verify in one call. This kind of root can answer split-view.
+- A retained checkpoint chain also answers split-view; the forest genesis document names the operator's bootstrap key. See https://github.com/forestrie/mcp-verify/blob/main/docs/trust-roots.md for when each root applies.
+
+Reporting: list each question with its status exactly as the verifier returned it, name the root, and say where the root came from (this server's key file, a chain read at a given block, someone else). Never turn "not answered" into "ok", and never edit the verifier's answers. If verification failed, quote the failing stage and its reason.
+
+Anyone holding the signed statement, the receipt and a root can re-run the check offline with @forestrie/mcp-verify. The receipt is evidence on its own; it does not depend on trusting this server.`;
+}
+export function issueAndPayPromptText(args) {
+    const purpose = args.purpose?.trim()
+        ? `What the grant is for: ${args.purpose.trim()}.`
+        : "If it is not clear what the grant is for, and so how large it must be, ask.";
+    return `Buy a grant on a Forestrie transparency log as the requester, with the @forestrie/mcp-register tools: sign a child grant under your own authority log, register it with canopy, pay if canopy asks, and hand the completed grant to whoever will write under it. ${purpose}
+
+Forestrie runs no grant issuer. You are the issuer: your authority key owns an authority log that the owner of the root above you created for you once. If that log carries the child-payment-required flag, every child grant registered under it is paid for over x402, and the payment goes straight to the transparency operator.
+
+You never handle keys or signature bytes. The server signs grants with its authority key and pays with its own payer; you never see either key, and you cannot raise its spending caps.
+
+1. Authority. Call get_log_key with which: "authority". You need an authority grant naming that key (FORESTRIE_AUTHORITY_GRANT, or pass parentGrant). If you have none, stop: give the publicKeyPem to the owner of the root above you and ask them to create your authority log for it. Its sealing must be delegated once, with delegate_sealing as: "authority" and that grant, or your child grants are sequenced but never sealed.
+
+2. Size. maxHeight is the grant's batch ceiling, and canopy prices a paid child grant as its unit price × maxHeight. Size it to the work it is for, no larger: a bigger grant costs more, and the server's per-call cap refuses one it cannot afford.
+
+3. Issue. Call issue_grant with maxHeight. By default it names this server's own log key, so the same agent writes (a self-purchase); pass grantee (base64 of a 64-byte x‖y) to issue to another agent's log key. Keep the logId it returns.
+
+4. Register and pay. Call register_grant with that logId.
+   - accepted: canopy took the grant (and the payment, if it asked for one). Go to 5.
+   - payment_required, no payer configured (relay mode): show the user the amount, asset, network and payee. Pay only with a wallet the user has authorised for this; give it the paymentRequiredHeader, then call register_grant again with the same logId and payment set to the X-PAYMENT value it returns. Never invent or edit a payment value.
+   - a cap_… problem: the server's own limit refused the payment. Report which cap and the amounts. Do not try to get around it: do not split the grant to slip under a cap, switch canopy, or retry in a loop. A smaller grant (step 2) or the user's decision are the ways forward.
+   - payment_rejected: canopy refused the payment; report its reason. Nothing was registered.
+   - a network error: call register_grant again with the same logId. It signs with the grant's own nonce again, so at most one payment can ever settle.
+
+5. Wait. Call register_grant with the logId until it reports complete: pending and awaiting_seal mean wait (seconds, then about a minute) and call again. Sealing takes minutes.
+
+6. Hand over. complete returns grantBase64, the completed grant. If it names this server's log key, continue with the register prompt: delegate_sealing with that grant, then register_statement. Otherwise give it to the performer whose key it names.
+
+Report what was paid, to whom, on which network, and the logId: the spend is recorded in this server's ledger, and the operator's receipt for the grant is the public record of the purchase.`;
+}
+//# sourceMappingURL=text.js.map

package/dist/node/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","sourceRoot":"","sources":["../../src/node/text.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,CAAC,MAAM,YAAY,GAAG;;;;;;;;2jBAQ+hB,CAAC;AAE5jB;;;eAGe;AACf,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,aAAa;IACb,oBAAoB;IACpB,oBAAoB;IACpB,qBAAqB;IACrB,kBAAkB;IAClB,aAAa;IACb,gBAAgB;CACR,CAAC;AAIX,MAAM,CAAC,MAAM,WAAW,GAA6B;IACnD,WAAW,EAAE,iBAAiB;IAC9B,kBAAkB,EAAE,+BAA+B;IACnD,kBAAkB,EAAE,sBAAsB;IAC1C,mBAAmB,EAAE,iCAAiC;IACtD,gBAAgB,EAAE,+BAA+B;IACjD,WAAW,EAAE,sCAAsC;IACnD,cAAc,EAAE,+CAA+C;CAChE,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAA6B;IACzD,WAAW,EACT,4eAA4e;IAC9e,kBAAkB,EAChB,+cAA+c;IACjd,kBAAkB,EAChB,ijBAAijB;IACnjB,mBAAmB,EACjB,8YAA8Y;IAChZ,gBAAgB,EACd,8dAA8d;IAChe,WAAW,EACT,6YAA6Y;IAC/Y,cAAc,EACZ,kvBAAkvB;CACrvB,CAAC;AAEF,2CAA2C;AAC3C,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,UAAU,EAAE,OAAO,EAAE,eAAe,CAAU,CAAC;AAI5E,MAAM,CAAC,MAAM,aAAa,GAA+B;IACvD,QAAQ,EAAE,2CAA2C;IACrD,KAAK,EAAE,qDAAqD;IAC5D,eAAe,EAAE,4CAA4C;CAC9D,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAA+B;IAC7D,QAAQ,EACN,oIAAoI;IACtI,KAAK,EACH,8GAA8G;IAChH,eAAe,EACb,0KAA0K;CAC7K,CAAC;AAEF,MAAM,UAAU,kBAAkB,CAAC,IAElC;IACC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE;QAC/B,CAAC,CAAC,8BAA8B,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG;QACnD,CAAC,CAAC,2DAA2D,CAAC;IAChE,OAAO,4IAA4I,OAAO;;;;;;;;;;;;;;kOAcsE,CAAC;AACnO,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,IAE/B;IACC,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,IAAI,EAAE;QACpC,CAAC,CAAC,2CAA2C,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,GAAG;QACvE,CAAC,CAAC,sDAAsD,CAAC;IAC3D,OAAO,+GAA+G,KAAK;;;;;;;;;;;qMAWwE,CAAC;AACtM,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,IAErC;IACC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE;QAClC,CAAC,CAAC,0BAA0B,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG;QAClD,CAAC,CAAC,6EAA6E,CAAC;IAClF,OAAO,oQAAoQ,OAAO;;;;;;;;;;;;;;;;;;;;;;;8LAuBtF,CAAC;AAC/L,CAAC"}