@codai/axiom-mcp 2.0.0 → 2.2.0

package/dist/axm-lazy.js

@@ -5809,13 +5809,30 @@ const ERROR_CODES = [
 	"ERR_PROVIDER_FAILED",
 	"ERR_GUARD_TIMEOUT",
 	"ERR_GUARD_OUTPUT",
+	"ERR_FACT_DISABLED",
+	"ERR_SIGNATURE_MISSING",
+	"ERR_SIGNATURE_INVALID",
+	"ERR_TRUST_STATE_CORRUPT",
+	"ERR_ROLLBACK",
+	"ERR_EMITTER_UNKNOWN",
+	"ERR_TEMPLATE_UNKNOWN",
+	"ERR_TEMPLATE_PARAMS",
+	"ERR_PATCH_FORMAT",
+	"ERR_PATCH_PREIMAGE",
+	"ERR_PATCH_NO_MATCH",
 	"ERR_GIT_NOT_FOUND",
 	"ERR_GIT_NOT_REPO",
 	"ERR_GIT_DIRTY",
 	"ERR_GIT_BRANCH_EXISTS",
 	"ERR_GIT_BRANCH_INVALID",
 	"ERR_GIT_FAILED",
+	"ERR_TASK_NOT_FOUND",
+	"ERR_TASK_CANCELLED",
+	"ERR_PLAN_SESSION_STATE",
 	"ERR_REF_OFFLINE",
+	"ERR_NET_DISABLED",
+	"ERR_NET_DENIED",
+	"ERR_NET_FAILED",
 	"ERR_NOT_CANONICAL",
 	"ERR_UNSUPPORTED_OP",
 	"ERR_INTERNAL"
@@ -5910,7 +5927,18 @@ object({
 	/** sha256(JCS(all facts)) → replayable. */
 	factsDigest: DigestRefSchema,
 	durationMs: int().nonnegative(),
-	providers: array(ProviderStatusSchema)
+	providers: array(ProviderStatusSchema),
+	/**
+	* S-402: how the manifest's `preImage` related to the tree at check time.
+	* `verified` = every entry matched; `drifted` = at least one differed (an `error`
+	* finding `ERR_PREIMAGE_CHANGED` is also emitted); `unverified` = no root, or the
+	* manifest carries no `preImage`.
+	*/
+	preImage: _enum([
+		"verified",
+		"drifted",
+		"unverified"
+	]).optional()
 }).strict();
 const ApiVersionSchema = literal("axiom.dev/v2");
 /** Per-blob inline limit: 256 KiB of string content (≈192 KiB decoded when base64). */
@@ -5950,7 +5978,18 @@ const PlanArtifactSourceSchema = discriminatedUnion("type", [
 		emitter: string().min(1),
 		template: string().min(1),
 		params: record(string(), json()).default({})
-	}).strict().describe("v2.1")
+	}).strict().describe("template source rendered by a registered emitter at compile time"),
+	object({
+		type: literal("patch"),
+		format: _enum([
+			"unified",
+			"v4a",
+			"search-replace"
+		]),
+		/** sha256 of the file the patch was authored against, or `absent` for a new file. */
+		preImage: union([DigestRefSchema, literal("absent")]),
+		body: string().max(INLINE_CONTENT_MAX)
+	}).strict().describe("patch applied at compile time to the pre-image named by its digest")
 ]);
 const PlanArtifactSchema = object({
 	path: RelPathSchema,
@@ -5981,6 +6020,8 @@ const PlanSchema = object({
 	capabilities: array(CapabilitySchema).default([]),
 	artifacts: array(PlanArtifactSchema).min(1).max(2e3),
 	checks: array(CheckRefSchema).default([]),
+	/** Anti-rollback counter (D-16); copied verbatim into `ManifestBody.counter`. */
+	counter: int().nonnegative().optional(),
 	metadata: record(string(), json()).default({})
 }).strict();
 const ErrorCodeSchema = _enum(ERROR_CODES);
@@ -6028,6 +6069,11 @@ object({
 	/** Path of `.axiom/journal/<digest>.json`. */
 	journal: string().optional(),
 	git: GitResultSchema.optional(),
+	/**
+	* Re-apply of an already-applied digest whose files no longer matched on disk:
+	* the artifacts listed here were re-written over foreign changes (design §apply).
+	*/
+	drifted: array(RelPathSchema).optional(),
 	error: ApplyErrorSchema.optional()
 }).strict().superRefine((r, ctx) => {
 	if (r.status === "failed" && r.error === void 0) ctx.addIssue({
@@ -6094,7 +6140,8 @@ const ManifestArtifactSchema = object({
 		"inline",
 		"template",
 		"cas",
-		"ref"
+		"ref",
+		"patch"
 	]).optional()
 }).strict().superRefine((a, ctx) => {
 	if (a.op !== "delete" && a.digest === void 0) ctx.addIssue({
@@ -6108,6 +6155,15 @@ const ToolchainSchema = object({
 	axiom: string().min(1),
 	emitters: record(string(), string())
 }).strict();
+/**
+* What compile saw on disk for one artifact path (S-402): the sha256 of the existing file
+* or `absent`. Binds a manifest — and every CheckReport/attestation over it — to the tree
+* it was produced against; `apply` refuses a different tree with `ERR_PREIMAGE_CHANGED`.
+*/
+const PreImageEntrySchema = object({
+	path: RelPathSchema,
+	sha256: union([Sha256HexSchema, literal("absent")])
+}).strict();
 /** The exact object that is JCS-canonicalised and sha256-hashed into `manifestDigest`. */
 const ManifestBodySchema = object({
 	apiVersion: ApiVersionSchema,
@@ -6120,8 +6176,25 @@ const ManifestBodySchema = object({
 	artifacts: array(ManifestArtifactSchema).min(1).max(2e3),
 	/** Sorted by id, unique (§2.4 determinism). */
 	checks: array(CheckRefSchema),
-	toolchain: ToolchainSchema
+	toolchain: ToolchainSchema,
+	/**
+	* Anti-rollback counter (D-16): monotonic per root, part of the canonical body so a
+	* signature binds it. Verified by `manifest.requireSigned { antiRollback: true }`.
+	*/
+	counter: int().nonnegative().optional(),
+	/**
+	* Pre-image of every artifact path at compile time (S-402), sorted by path, unique;
+	* present when compile had a root (or a pre-image reader). Part of the canonical body:
+	* the same Plan compiled against a different tree is a different manifest.
+	*/
+	preImage: array(PreImageEntrySchema).optional()
 }).strict().superRefine((m, ctx) => {
+	if (m.preImage !== void 0 && !isSortedUnique(m.preImage.map((p) => p.path))) ctx.addIssue({
+		code: "custom",
+		path: ["preImage"],
+		message: "preImage must be sorted by path (UTF-8 byte order) and unique",
+		params: { code: "ERR_NOT_CANONICAL" }
+	});
 	if (!isSortedUnique(m.artifacts.map((a) => a.path))) ctx.addIssue({
 		code: "custom",
 		path: ["artifacts"],
@@ -6155,7 +6228,7 @@ const InTotoStatementLooseSchema = object({
 	predicateType: url(),
 	predicate: record(string(), unknown())
 }).strict();
-/** DSSE envelope (secure-systems-lab/dsse v1.0.2). */
+/** DSSE envelope (secure-systems-lab/dsse v1.0.2) around an in-toto attestation. */
 const DsseEnvelopeSchema = object({
 	payloadType: literal("application/vnd.in-toto+json"),
 	payload: base64(),
@@ -6164,11 +6237,71 @@ const DsseEnvelopeSchema = object({
 		sig: base64()
 	}).strict())
 }).strict();
+/** DSSE payloadType of a signed `ManifestBody` (D-16). */
+const AXIOM_MANIFEST_PAYLOAD_TYPE = "application/vnd.axiom.manifest+json";
+/**
+* DSSE payloadType of a **root-bound** signature (S-409): the payload is
+* `JCS({ manifest, rootId })`, so the same key's signature over the same manifest is not
+* valid for a root whose trust store declares a different `rootId`.
+*/
+const AXIOM_MANIFEST_BOUND_PAYLOAD_TYPE = "application/vnd.axiom.manifest-bound+json";
+/** Operator-chosen root identity, e.g. `github:dragoscv/brivio` or a UUID. */
+const RootIdSchema = string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@-]*$/, "rootId: letters, digits, . _ : / @ - only");
+/**
+* DSSE envelope whose payload is `base64(JCS(manifest))`, signed with Ed25519 (D-16).
+* Lives outside the canonical body: `manifestDigest` is unchanged whether signed or not.
+* With `payloadType` = `AXIOM_MANIFEST_BOUND_PAYLOAD_TYPE` the payload is
+* `base64(JCS({ manifest, rootId }))` (S-409).
+*/
+const ManifestSignatureSchema = object({
+	payloadType: union([literal(AXIOM_MANIFEST_PAYLOAD_TYPE), literal(AXIOM_MANIFEST_BOUND_PAYLOAD_TYPE)]),
+	payload: base64(),
+	signatures: array(object({
+		keyid: string().optional(),
+		sig: base64()
+	}).strict()).min(1)
+}).strict();
+/** `.axiom/trust/keys.json` — the per-root allowlist of signing keys (D-16). */
+const TrustedKeySchema = object({
+	/** sha256(raw 32-byte public key), lowercase hex. */
+	keyid: string().regex(/^[0-9a-f]{64}$/),
+	alg: literal("ed25519"),
+	/** base64 of the raw 32-byte Ed25519 public key. */
+	publicKey: base64(),
+	name: string().min(1).max(200).optional(),
+	/** Lowest manifest `counter` this key may sign for. */
+	notBefore: int().nonnegative().optional()
+}).strict();
+object({
+	version: literal(1),
+	keys: array(TrustedKeySchema),
+	/** Floor for `counter` when no state has been recorded yet. */
+	minCounter: int().nonnegative().optional(),
+	/**
+	* When set, only root-bound signatures carrying this exact id count (S-409): an
+	* unbound or differently-bound envelope is `signature.unbound`. Absent → both accepted.
+	*/
+	rootId: RootIdSchema.optional()
+}).strict();
+object({
+	version: literal(1),
+	lastCounter: int().nonnegative(),
+	/** Digest of the manifest that advanced `lastCounter` (informational). */
+	manifestDigest: DigestRefSchema.optional(),
+	/**
+	* HMAC-SHA256 (hex) over `JCS(state without mac)` keyed by `.axiom/trust/state.key`
+	* (S-409). Written by every `advanceTrustState`; a state with a key on disk but a
+	* missing/wrong mac is `ERR_TRUST_STATE_CORRUPT`.
+	*/
+	mac: string().regex(/^[0-9a-f]{64}$/).optional()
+}).strict();
 object({
 	manifest: ManifestBodySchema,
 	manifestDigest: DigestRefSchema,
 	attestation: InTotoStatementLooseSchema.optional(),
 	envelope: DsseEnvelopeSchema.optional(),
+	/** Detached DSSE signatures over `manifest` (D-16). Not part of `manifestDigest`. */
+	signatures: array(ManifestSignatureSchema).optional(),
 	/** Inline side-channel keyed by `sha256:<hex>`. */
 	blobs: record(DigestRefSchema, BlobSchema).default({})
 }).strict().superRefine((b, ctx) => {
@@ -6204,6 +6337,32 @@ object({
 	limits: ProfileLimitsSchema.default({}),
 	facts: ProfileFactsSchema.prefault({})
 }).strict();
+const RepoSnapshotEntryKindSchema = _enum(["file", "symlink"]);
+/** The hashed part: `snapshotDigest = sha256(JCS(body))`. No timestamps, no absolute paths. */
+const RepoSnapshotBodySchema = object({
+	/** Sorted by `compareUtf8(path)`. */
+	files: array(object({
+		path: RelPathSchema,
+		bytes: int().nonnegative(),
+		sha256: Sha256HexSchema.optional(),
+		mode: ArtifactModeSchema,
+		kind: RepoSnapshotEntryKindSchema
+	}).strict()),
+	/** True when `maxFiles` or `maxBytes` stopped the walk; `files` is then a prefix of the full order. */
+	truncated: boolean(),
+	counts: object({
+		files: int().nonnegative(),
+		bytes: int().nonnegative()
+	}).strict()
+}).strict();
+object({
+	apiVersion: ApiVersionSchema,
+	kind: literal("RepoSnapshot"),
+	/** Paths are relative to the walked root; the root itself is deliberately not recorded. */
+	root: object({ kind: literal("relative") }).strict(),
+	snapshotDigest: DigestRefSchema,
+	body: RepoSnapshotBodySchema
+}).strict();
 //#endregion
 //#region ../../node_modules/.pnpm/@chevrotain+utils@13.2.0/node_modules/@chevrotain/utils/lib/src/print.js
 function PRINT_ERROR(msg) {
@@ -12067,6 +12226,7 @@ const ModeKw = keyword("ModeKw", "mode");
 const OpKw = keyword("OpKw", "op");
 const Inline = keyword("Inline", "inline");
 const Template = keyword("Template", "template");
+const Patch = keyword("Patch", "patch");
 const Cas = keyword("Cas", "cas");
 const Ref = keyword("Ref", "ref");
 const Check = keyword("Check", "check");
@@ -12243,6 +12403,7 @@ const allTokens = [
 	OpKw,
 	Inline,
 	Template,
+	Patch,
 	Cas,
 	Ref,
 	Check,
@@ -12515,6 +12676,26 @@ var Compiler = class {
 				params: params ?? {}
 			};
 		}
+		const patch = first(nodes(ctx, "patchSource"));
+		if (patch !== void 0) {
+			const pc = patch.children;
+			const f = first(tokens(pc, "format"));
+			const d = first(tokens(pc, "preImage"));
+			const ab = first(tokens(pc, "absent"));
+			const h = first(tokens(pc, "body"));
+			this.at(`${path}.format`, tokenRange(f));
+			this.at(`${path}.preImage`, tokenRange(d ?? ab ?? f));
+			this.at(`${path}.body`, tokenRange(h));
+			if (ab !== void 0 && ab.image !== "absent") this.error("patch pre-image must be a \"sha256:…\" digest or the word absent", tokenRange(ab));
+			const payload = h?.payload;
+			const body = payload === void 0 ? "" : `${payload.content}\n`;
+			return {
+				type: "patch",
+				format: f?.image ?? "",
+				preImage: d !== void 0 ? decodeString(d.image) : "absent",
+				body
+			};
+		}
 	}
 	check(n, path) {
 		const ctx = n.children;
@@ -12588,7 +12769,8 @@ function compileCst(file) {
 *   PlanItem    = "intent" String | "profile" Ident | "capabilities" "[" [Cap {"," Cap}] "]"
 *               | "artifact" String ArtifactBody | "check" Ident "using" QualIdent [Json] | "meta" Json ;
 *   ArtifactBody= "{", { "mode" Mode | "op" Op | Source }, "}" ;
-*   Source      = "inline" HereDoc | "template" QualIdent String [Json] | "cas" Digest | "ref" String Digest ;
+*   Source      = "inline" HereDoc | "template" QualIdent String [Json] | "cas" Digest | "ref" String Digest
+*               | "patch" Format ( Digest | "absent" ) HereDoc ;      Format = unified | v4a | search-replace
 *   QualIdent   = Ident, { ".", Ident } ;
 */
 var AxmParser = class extends CstParser {
@@ -12670,9 +12852,16 @@ var AxmParser = class extends CstParser {
 			{ ALT: () => this.SUBRULE(this.inlineSource) },
 			{ ALT: () => this.SUBRULE(this.templateSource) },
 			{ ALT: () => this.SUBRULE(this.casSource) },
-			{ ALT: () => this.SUBRULE(this.refSource) }
+			{ ALT: () => this.SUBRULE(this.refSource) },
+			{ ALT: () => this.SUBRULE(this.patchSource) }
 		]);
 	});
+	patchSource = this.RULE("patchSource", () => {
+		this.CONSUME(Patch);
+		this.CONSUME(IdentLike, { LABEL: "format" });
+		this.OR([{ ALT: () => this.CONSUME(Digest, { LABEL: "preImage" }) }, { ALT: () => this.CONSUME2(IdentLike, { LABEL: "absent" }) }]);
+		this.CONSUME(HereDoc, { LABEL: "body" });
+	});
 	inlineSource = this.RULE("inlineSource", () => {
 		this.CONSUME(Inline);
 		this.CONSUME(HereDoc, { LABEL: "content" });