@honua/mcp-server 0.1.2-beta.0 → 0.1.8-beta.0

package/dist/src/release/zero-to-map-checkpoint.js

@@ -0,0 +1,369 @@
+import { createHash } from "node:crypto";
+import { ZERO_TO_MAP_CATALOG_RECEIPT_SCHEMA, ZERO_TO_MAP_CONSOLE_RECEIPT_REQUEST_SCHEMA, } from "./zero-to-map.js";
+export const ZERO_TO_MAP_CHECKPOINT_SCHEMA = "honua.zero-to-map.checkpoint/v1";
+export const ZERO_TO_MAP_CHECKPOINT_MAX_AGE_MS = 24 * 60 * 60 * 1_000;
+export function createZeroToMapCheckpoint(bindings, snapshot, createdAt = new Date().toISOString()) {
+    assertTargetBinding(bindings);
+    const payload = {
+        schemaVersion: ZERO_TO_MAP_CHECKPOINT_SCHEMA,
+        state: "paused",
+        createdAt,
+        ...bindings,
+        resume: {
+            startedAt: snapshot.startedAt,
+            capturedVariables: snapshot.capturedVariables,
+            completedStages: snapshot.completedStages,
+            resumeAt: snapshot.resumeAt,
+            // Carried across the Console boundary because no post-checkpoint stage
+            // can re-derive it; the resumed run's final receipt would otherwise
+            // overwrite the pre-pause receipt with one that has no catalog evidence.
+            ...(snapshot.catalog ? { catalog: snapshot.catalog } : {}),
+        },
+        consoleReceiptRequest: snapshot.consoleReceiptRequest,
+    };
+    assertSecretFree(payload);
+    return seal(payload);
+}
+export function consumeZeroToMapCheckpoint(checkpoint, finalReceiptSha256, consumedAt = new Date().toISOString()) {
+    if (checkpoint.state !== "paused")
+        throw new Error("checkpoint has already been consumed");
+    const { integrity: _integrity, ...prior } = checkpoint;
+    return seal({ ...prior, state: "consumed", consumedAt, finalReceiptSha256 });
+}
+export function parseZeroToMapCheckpoint(value) {
+    const checkpoint = object(value, "checkpoint");
+    exactKeys(checkpoint, [
+        "schemaVersion",
+        "state",
+        "createdAt",
+        "journeyId",
+        "releaseContract",
+        "target",
+        "planSha256",
+        "sourceRevision",
+        "mcpEndpointSha256",
+        "candidateId",
+        "releaseId",
+        "provisionReceiptSha256",
+        "resume",
+        "consoleReceiptRequest",
+        "consumedAt",
+        "finalReceiptSha256",
+        "integrity",
+    ], "checkpoint");
+    if (checkpoint.schemaVersion !== ZERO_TO_MAP_CHECKPOINT_SCHEMA) {
+        throw new Error(`checkpoint.schemaVersion must be ${ZERO_TO_MAP_CHECKPOINT_SCHEMA}`);
+    }
+    if (checkpoint.state !== "paused" && checkpoint.state !== "consumed") {
+        throw new Error("checkpoint.state must be paused or consumed");
+    }
+    const createdAt = timestamp(checkpoint.createdAt, "checkpoint.createdAt");
+    const bindings = {
+        journeyId: text(checkpoint.journeyId, "checkpoint.journeyId"),
+        releaseContract: text(checkpoint.releaseContract, "checkpoint.releaseContract"),
+        target: target(checkpoint.target),
+        planSha256: sha256(checkpoint.planSha256, "checkpoint.planSha256"),
+        sourceRevision: revision(checkpoint.sourceRevision, "checkpoint.sourceRevision"),
+        mcpEndpointSha256: sha256(checkpoint.mcpEndpointSha256, "checkpoint.mcpEndpointSha256"),
+        candidateId: text(checkpoint.candidateId, "checkpoint.candidateId"),
+        releaseId: text(checkpoint.releaseId, "checkpoint.releaseId"),
+        ...(checkpoint.provisionReceiptSha256 === undefined
+            ? {}
+            : {
+                provisionReceiptSha256: sha256(checkpoint.provisionReceiptSha256, "checkpoint.provisionReceiptSha256"),
+            }),
+    };
+    assertTargetBinding(bindings);
+    const resume = parseResume(checkpoint.resume);
+    const consoleReceiptRequest = parseReceiptRequest(checkpoint.consoleReceiptRequest);
+    const integrity = object(checkpoint.integrity, "checkpoint.integrity");
+    exactKeys(integrity, ["algorithm", "digest"], "checkpoint.integrity");
+    if (integrity.algorithm !== "sha256")
+        throw new Error("checkpoint.integrity.algorithm must be sha256");
+    const digest = sha256(integrity.digest, "checkpoint.integrity.digest");
+    const state = checkpoint.state;
+    const consumedAt = checkpoint.consumedAt;
+    const finalReceiptSha256 = checkpoint.finalReceiptSha256;
+    if (state === "paused" && (consumedAt !== undefined || finalReceiptSha256 !== undefined)) {
+        throw new Error("paused checkpoint cannot carry consumed receipt fields");
+    }
+    if (state === "consumed" && (consumedAt === undefined || finalReceiptSha256 === undefined)) {
+        throw new Error("consumed checkpoint must carry consumedAt and finalReceiptSha256");
+    }
+    const payload = {
+        schemaVersion: ZERO_TO_MAP_CHECKPOINT_SCHEMA,
+        state,
+        createdAt,
+        ...bindings,
+        resume,
+        consoleReceiptRequest,
+        ...(state === "consumed"
+            ? {
+                consumedAt: timestamp(consumedAt, "checkpoint.consumedAt"),
+                finalReceiptSha256: sha256(finalReceiptSha256, "checkpoint.finalReceiptSha256"),
+            }
+            : {}),
+    };
+    assertSecretFree(payload);
+    const expected = digestPayload(payload);
+    if (digest !== expected)
+        throw new Error("checkpoint integrity digest does not match its canonical payload");
+    return { ...payload, integrity: { algorithm: "sha256", digest } };
+}
+export function assertZeroToMapCheckpointFresh(checkpoint, now = new Date()) {
+    const age = now.getTime() - Date.parse(checkpoint.createdAt);
+    if (age < 0 || age > ZERO_TO_MAP_CHECKPOINT_MAX_AGE_MS) {
+        throw new Error("checkpoint is stale or has a future creation time");
+    }
+}
+export function assertZeroToMapCheckpointDigest(checkpoint, expectedDigest) {
+    if (!/^[0-9a-f]{64}$/.test(expectedDigest) || checkpoint.integrity.digest !== expectedDigest) {
+        throw new Error("externally carried checkpoint digest does not match");
+    }
+}
+export function assertZeroToMapCheckpointBindings(checkpoint, expected) {
+    for (const key of Object.keys(expected)) {
+        if (checkpoint[key] !== expected[key])
+            throw new Error(`checkpoint binding mismatch: ${key}`);
+    }
+}
+function assertTargetBinding(bindings) {
+    if (bindings.target === "aws-ecs" && bindings.provisionReceiptSha256 === undefined) {
+        throw new Error("AWS ECS checkpoint must bind provisionReceiptSha256");
+    }
+    if (bindings.target === "local-docker" && bindings.provisionReceiptSha256 !== undefined) {
+        throw new Error("local Docker checkpoint cannot bind an AWS provision receipt");
+    }
+}
+function seal(payload) {
+    return { ...payload, integrity: { algorithm: "sha256", digest: digestPayload(payload) } };
+}
+function digestPayload(payload) {
+    return createHash("sha256").update(canonicalJson(payload)).digest("hex");
+}
+/** Checkpoints are an allowlisted release handoff, never a credential transport. */
+function assertSecretFree(value, path = "checkpoint") {
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => assertSecretFree(item, `${path}[${index}]`));
+        return;
+    }
+    if (!value || typeof value !== "object")
+        return;
+    for (const [key, item] of Object.entries(value)) {
+        if (/(?:password|authorization|api[-_]?key|access[-_]?key|secret(?:[-_]?key)?|bearer|token|material)/i.test(key)) {
+            throw new Error(`checkpoint contains a forbidden credential field at ${path}.${key}`);
+        }
+        assertSecretFree(item, `${path}.${key}`);
+    }
+}
+function canonicalJson(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (typeof value === "object") {
+        const candidate = value;
+        return `{${Object.keys(candidate)
+            .filter((key) => candidate[key] !== undefined)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonicalJson(candidate[key])}`)
+            .join(",")}}`;
+    }
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined)
+        throw new Error("checkpoint contains a non-JSON value");
+    return encoded;
+}
+function parseResume(value) {
+    const resume = object(value, "checkpoint.resume");
+    exactKeys(resume, ["startedAt", "capturedVariables", "completedStages", "resumeAt", "catalog"], "checkpoint.resume");
+    const capturedVariables = object(resume.capturedVariables, "checkpoint.resume.capturedVariables");
+    if (!Array.isArray(resume.completedStages))
+        throw new Error("checkpoint.resume.completedStages must be an array");
+    return {
+        startedAt: timestamp(resume.startedAt, "checkpoint.resume.startedAt"),
+        capturedVariables,
+        completedStages: resume.completedStages.map(parseStageReceipt),
+        resumeAt: parseResumePoint(resume.resumeAt),
+        ...(resume.catalog === undefined ? {} : { catalog: parseCatalogReceipt(resume.catalog) }),
+    };
+}
+/**
+ * Catalog preflight evidence restored from the checkpoint. Validated as
+ * strictly as the rest of the payload: it is re-emitted onto the final release
+ * receipt, so a malformed or padded catalog block must not survive the parse.
+ */
+function parseCatalogReceipt(value) {
+    const path = "checkpoint.resume.catalog";
+    const catalog = object(value, path);
+    exactKeys(catalog, [
+        "schemaVersion",
+        "activeProfiles",
+        "expectedTotalTools",
+        "advertisedTotalTools",
+        "baseStaticTools",
+        "baseAdminTools",
+        "auditedExclusions",
+        "profiles",
+        "catalogSha256",
+        "adminRosterSha256",
+        "staticRosterSha256",
+        "exclusionRosterSha256",
+    ], path);
+    if (catalog.schemaVersion !== ZERO_TO_MAP_CATALOG_RECEIPT_SCHEMA) {
+        throw new Error(`${path}.schemaVersion must be ${ZERO_TO_MAP_CATALOG_RECEIPT_SCHEMA}`);
+    }
+    if (!Array.isArray(catalog.profiles))
+        throw new Error(`${path}.profiles must be an array`);
+    return {
+        schemaVersion: ZERO_TO_MAP_CATALOG_RECEIPT_SCHEMA,
+        activeProfiles: stringList(catalog.activeProfiles, `${path}.activeProfiles`),
+        expectedTotalTools: count(catalog.expectedTotalTools, `${path}.expectedTotalTools`),
+        advertisedTotalTools: count(catalog.advertisedTotalTools, `${path}.advertisedTotalTools`),
+        baseStaticTools: count(catalog.baseStaticTools, `${path}.baseStaticTools`),
+        baseAdminTools: count(catalog.baseAdminTools, `${path}.baseAdminTools`),
+        auditedExclusions: count(catalog.auditedExclusions, `${path}.auditedExclusions`),
+        profiles: catalog.profiles.map((profile, index) => parseProfileReceipt(profile, `${path}.profiles[${index}]`)),
+        catalogSha256: sha256(catalog.catalogSha256, `${path}.catalogSha256`),
+        adminRosterSha256: sha256(catalog.adminRosterSha256, `${path}.adminRosterSha256`),
+        staticRosterSha256: sha256(catalog.staticRosterSha256, `${path}.staticRosterSha256`),
+        exclusionRosterSha256: sha256(catalog.exclusionRosterSha256, `${path}.exclusionRosterSha256`),
+    };
+}
+function parseProfileReceipt(value, path) {
+    const profile = object(value, path);
+    exactKeys(profile, ["id", "expectedMembers", "advertisedMembers", "confirmedMembers", "nameResolvedMembers", "rosterSha256"], path);
+    return {
+        id: text(profile.id, `${path}.id`),
+        expectedMembers: count(profile.expectedMembers, `${path}.expectedMembers`),
+        advertisedMembers: count(profile.advertisedMembers, `${path}.advertisedMembers`),
+        confirmedMembers: stringList(profile.confirmedMembers, `${path}.confirmedMembers`),
+        nameResolvedMembers: stringList(profile.nameResolvedMembers, `${path}.nameResolvedMembers`),
+        rosterSha256: sha256(profile.rosterSha256, `${path}.rosterSha256`),
+    };
+}
+function parseResumePoint(value) {
+    const point = object(value, "checkpoint.resume.resumeAt");
+    exactKeys(point, ["stageId", "actionId"], "checkpoint.resume.resumeAt");
+    return {
+        stageId: text(point.stageId, "checkpoint.resume.resumeAt.stageId"),
+        actionId: text(point.actionId, "checkpoint.resume.resumeAt.actionId"),
+    };
+}
+function parseReceiptRequest(value) {
+    const request = object(value, "checkpoint.consoleReceiptRequest");
+    exactKeys(request, ["schemaVersion", "actionId", "receiptSchema", "matches", "requiredPointers", "equalPointers"], "checkpoint.consoleReceiptRequest");
+    if (request.schemaVersion !== ZERO_TO_MAP_CONSOLE_RECEIPT_REQUEST_SCHEMA) {
+        throw new Error(`checkpoint.consoleReceiptRequest.schemaVersion must be ${ZERO_TO_MAP_CONSOLE_RECEIPT_REQUEST_SCHEMA}`);
+    }
+    const matches = object(request.matches, "checkpoint.consoleReceiptRequest.matches");
+    const requiredPointers = stringList(request.requiredPointers, "checkpoint.consoleReceiptRequest.requiredPointers");
+    if (!Array.isArray(request.equalPointers)) {
+        throw new Error("checkpoint.consoleReceiptRequest.equalPointers must be an array");
+    }
+    const equalPointers = request.equalPointers.map((value, index) => {
+        if (!Array.isArray(value) || value.length !== 2 || value.some((item) => typeof item !== "string" || !item)) {
+            throw new Error(`checkpoint.consoleReceiptRequest.equalPointers[${index}] must be a pointer pair`);
+        }
+        return [value[0], value[1]];
+    });
+    return {
+        schemaVersion: ZERO_TO_MAP_CONSOLE_RECEIPT_REQUEST_SCHEMA,
+        actionId: text(request.actionId, "checkpoint.consoleReceiptRequest.actionId"),
+        receiptSchema: text(request.receiptSchema, "checkpoint.consoleReceiptRequest.receiptSchema"),
+        matches,
+        requiredPointers,
+        equalPointers,
+    };
+}
+function parseStageReceipt(value, index) {
+    const path = `checkpoint.resume.completedStages[${index}]`;
+    const stage = object(value, path);
+    exactKeys(stage, ["number", "id", "title", "status", "actions"], path);
+    if (!Number.isInteger(stage.number) || stage.number < 1)
+        throw new Error(`${path}.number must be positive`);
+    if (!Array.isArray(stage.actions))
+        throw new Error(`${path}.actions must be an array`);
+    return {
+        number: stage.number,
+        id: text(stage.id, `${path}.id`),
+        title: text(stage.title, `${path}.title`),
+        status: actionStatus(stage.status, `${path}.status`),
+        actions: stage.actions.map((action, actionIndex) => parseActionReceipt(action, `${path}.actions[${actionIndex}]`)),
+    };
+}
+function parseActionReceipt(value, path) {
+    const action = object(value, path);
+    exactKeys(action, ["id", "kind", "status", "startedAt", "finishedAt", "code", "message", "evidence", "captures"], path);
+    const kind = action.kind;
+    if (!["cli", "mcp", "mcp-resource", "gpserver", "receipt", "http"].includes(String(kind))) {
+        throw new Error(`${path}.kind is invalid`);
+    }
+    return {
+        id: text(action.id, `${path}.id`),
+        kind: kind,
+        status: actionStatus(action.status, `${path}.status`),
+        startedAt: timestamp(action.startedAt, `${path}.startedAt`),
+        finishedAt: timestamp(action.finishedAt, `${path}.finishedAt`),
+        ...(action.code === undefined ? {} : { code: text(action.code, `${path}.code`) }),
+        ...(action.message === undefined ? {} : { message: text(action.message, `${path}.message`) }),
+        ...(action.evidence === undefined ? {} : { evidence: object(action.evidence, `${path}.evidence`) }),
+        ...(action.captures === undefined ? {} : { captures: object(action.captures, `${path}.captures`) }),
+    };
+}
+function actionStatus(value, path) {
+    if (value !== "passed" && value !== "blocked" && value !== "failed" && value !== "skipped") {
+        throw new Error(`${path} is invalid`);
+    }
+    return value;
+}
+function object(value, path) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`${path} must be an object`);
+    return value;
+}
+function exactKeys(value, allowed, path) {
+    const extras = Object.keys(value).filter((key) => !allowed.includes(key));
+    if (extras.length > 0)
+        throw new Error(`${path} has unknown fields: ${extras.join(", ")}`);
+}
+function text(value, path) {
+    if (typeof value !== "string" || !value)
+        throw new Error(`${path} must be a non-empty string`);
+    return value;
+}
+function timestamp(value, path) {
+    const result = text(value, path);
+    if (!Number.isFinite(Date.parse(result)))
+        throw new Error(`${path} must be an ISO timestamp`);
+    return result;
+}
+function sha256(value, path) {
+    const result = text(value, path);
+    if (!/^[0-9a-f]{64}$/.test(result))
+        throw new Error(`${path} must be a lowercase SHA-256 digest`);
+    return result;
+}
+function revision(value, path) {
+    const result = text(value, path);
+    if (!/^[0-9a-f]{40}$/.test(result))
+        throw new Error(`${path} must be a full lowercase git SHA`);
+    return result;
+}
+function target(value) {
+    if (value !== "local-docker" && value !== "aws-ecs") {
+        throw new Error("checkpoint.target must be local-docker or aws-ecs");
+    }
+    return value;
+}
+function count(value, path) {
+    if (!Number.isInteger(value) || value < 0)
+        throw new Error(`${path} must be a non-negative integer`);
+    return value;
+}
+function stringList(value, path) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !item)) {
+        throw new Error(`${path} must be an array of non-empty strings`);
+    }
+    return value;
+}

package/dist/src/release/zero-to-map-cli.d.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { type AwsEcsProvisionBinding } from "./zero-to-map-provision.js";
+import { type JourneyExecutionResult, type JourneyMcpResourceAction } from "./zero-to-map.js";
+type JourneyTarget = "local-docker" | "aws-ecs";
+export interface CliOptions {
+    readonly execute: boolean;
+    readonly confirmed: boolean;
+    readonly planPath: string;
+    readonly outputPath: string;
+    readonly honuaCommand: string;
+    readonly target: JourneyTarget;
+    readonly mcpUrl?: string;
+    readonly checkpointPath?: string;
+    readonly checkpointDigest?: string;
+    readonly provisionReceiptPath?: string;
+    readonly consoleReceiptPath?: string;
+    readonly provisionBinding?: AwsEcsProvisionBinding;
+    readonly provisionReceiptSha256?: string;
+    readonly sourceRevision?: string;
+    readonly variables: Readonly<Record<string, unknown>>;
+    readonly receiptPaths: Readonly<Record<string, string>>;
+}
+export declare function runZeroToMapCli(argv?: readonly string[], env?: NodeJS.ProcessEnv): Promise<number>;
+export declare function parseZeroToMapCliArgs(argv: readonly string[], env: NodeJS.ProcessEnv): CliOptions;
+/** Resolve the live mutating CLI without permitting Windows' cwd-first executable search. */
+export declare function resolveLiveExecutable(command: string, env: NodeJS.ProcessEnv, excludedDirectory: string): Promise<string>;
+/** Atomically transfer one paused checkpoint to a single resume owner. */
+export declare function claimZeroToMapCheckpoint(path: string, digest: string): Promise<string>;
+export declare function parseInstallAccessCredential(stdout: string): {
+    readonly id: string;
+    readonly name: string;
+    readonly status: "active";
+    readonly requestedGrants: readonly string[];
+    readonly effectiveGrants: readonly string[];
+    readonly canAuthenticate: true;
+    readonly referenceType: "private-env-file";
+    readonly referenceDigestSha256: string;
+    readonly provisioned: boolean;
+};
+/** Poll one MCP job resource to its declared successful terminal state. */
+export declare function readJourneyMcpResource(action: JourneyMcpResourceAction, read: (uri: string) => Promise<unknown>): Promise<JourneyExecutionResult>;
+export declare function requireCompletedPublishedOperation(tool: string, value: unknown): {
+    operationId: string;
+    status: string;
+    handleId?: string;
+    approvalLane?: string;
+    jobId?: string;
+    metadataRevision?: number;
+} | undefined;
+export {};
+//# sourceMappingURL=zero-to-map-cli.d.ts.map

package/dist/src/release/zero-to-map-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zero-to-map-cli.d.ts","sourceRoot":"","sources":["../../../src/release/zero-to-map-cli.ts"],"names":[],"mappings":"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"}