@astrosheep/keiyaku 4.0.4 → 4.0.6

package/build/src/akuma/request-wire.js

@@ -0,0 +1,383 @@
+import { randomUUID } from "node:crypto";
+import { rename, rm, writeFile } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+import { decodeAllowedActions } from "./allowed.js";
+import { archetypeName, parseAkuId } from "./identity.js";
+import { decodeProviderOptions, decodeReadonlyRestraint, } from "./provider-recipe.js";
+import { decodeProviderExecution } from "./providers/index.js";
+import { decodeTaskMutationRequest, isTaskMutationAction, } from "../task/mutation.js";
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function exactKeys(value, expected) {
+    const actual = Object.keys(value).sort();
+    const sorted = [...expected].sort();
+    return actual.length === sorted.length && actual.every((key, index) => key === sorted[index]);
+}
+export function absolute(value) {
+    return typeof value === "string" && isAbsolute(value) && resolve(value) === value;
+}
+export function canonicalAkuId(value) {
+    if (typeof value !== "string")
+        return null;
+    try {
+        const id = parseAkuId(value).id;
+        return id === value ? id : null;
+    }
+    catch {
+        return null;
+    }
+}
+function canonicalTargets(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return null;
+    const ids = [];
+    for (const item of value) {
+        const id = canonicalAkuId(item);
+        if (id === null
+            || (ids.length > 0
+                && Buffer.compare(Buffer.from(ids.at(-1)), Buffer.from(id)) >= 0))
+            return null;
+        ids.push(id);
+    }
+    return ids;
+}
+export function decodeRecipe(value) {
+    const recipe = object(value);
+    if (recipe === null)
+        return null;
+    const expected = [
+        "allowed",
+        "options",
+        "provider",
+        ...(recipe.description === undefined ? [] : ["description"]),
+        ...(recipe.readonly === undefined ? [] : ["readonly"]),
+    ];
+    if (!exactKeys(recipe, expected)
+        || (recipe.description !== undefined
+            && (typeof recipe.description !== "string"
+                || recipe.description.trim().length === 0)))
+        return null;
+    try {
+        const options = decodeProviderOptions(recipe.options);
+        const readonly = recipe.readonly === undefined ? undefined : decodeReadonlyRestraint(recipe.readonly);
+        if ((options.readonly === true) !== (readonly !== undefined))
+            return null;
+        return Object.freeze({
+            ...(recipe.description === undefined ? {} : { description: recipe.description }),
+            allowed: decodeAllowedActions(recipe.allowed),
+            provider: decodeProviderExecution(recipe.provider),
+            options,
+            ...(readonly === undefined ? {} : { readonly }),
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function contractId(value) {
+    return typeof value === "string" && /^kei\/[^/\s]+$/u.test(value) ? value : null;
+}
+function decodeCall(id, payload) {
+    const expected = [
+        "archetype",
+        "body",
+        "recipe",
+        "world",
+        ...(payload.cwd === undefined ? [] : ["cwd"]),
+    ];
+    if (!exactKeys(payload, expected)
+        || typeof payload.body !== "string"
+        || !absolute(payload.world)
+        || (payload.cwd !== undefined && !absolute(payload.cwd)))
+        return null;
+    try {
+        archetypeName(payload.archetype);
+    }
+    catch {
+        return null;
+    }
+    return {
+        id,
+        action: "akuma.call",
+        world: payload.world,
+        archetype: payload.archetype,
+        body: payload.body,
+        recipe: payload.recipe,
+        ...(payload.cwd === undefined ? {} : { cwd: payload.cwd }),
+    };
+}
+function decodeWait(id, payload) {
+    const targets = canonicalTargets(payload.targets);
+    const expected = [
+        "completion",
+        "targets",
+        ...(payload.timeoutMs === undefined ? [] : ["timeoutMs"]),
+    ];
+    if (!exactKeys(payload, expected)
+        || targets === null
+        || (payload.completion !== "any" && payload.completion !== "all")
+        || (payload.timeoutMs !== undefined
+            && (!Number.isSafeInteger(payload.timeoutMs)
+                || payload.timeoutMs < 0)))
+        return null;
+    return {
+        id,
+        action: "akuma.wait",
+        targets,
+        completion: payload.completion,
+        ...(payload.timeoutMs === undefined
+            ? {}
+            : { timeoutMs: payload.timeoutMs }),
+    };
+}
+function decodeTell(id, payload) {
+    const target = canonicalAkuId(payload.target);
+    return exactKeys(payload, ["body", "target"])
+        && target !== null
+        && typeof payload.body === "string"
+        ? { id, action: "akuma.tell", target, body: payload.body }
+        : null;
+}
+function decodeKill(id, payload) {
+    const targets = canonicalTargets(payload.targets);
+    return exactKeys(payload, ["targets"])
+        && targets !== null
+        ? { id, action: "akuma.kill", targets }
+        : null;
+}
+function decodeDeliver(id, payload) {
+    const valid = exactKeys(payload, [
+        "contractId",
+        "includeDirty",
+        "materializeConflict",
+        "repoRoot",
+        ...(payload.message === undefined ? [] : ["message"]),
+    ]);
+    const selected = contractId(payload.contractId);
+    return valid
+        && selected !== null
+        && absolute(payload.repoRoot)
+        && typeof payload.includeDirty === "boolean"
+        && typeof payload.materializeConflict === "boolean"
+        && (payload.message === undefined
+            || (typeof payload.message === "string"
+                && payload.message.trim().length > 0))
+        ? {
+            id,
+            action: "contract.deliver",
+            repoRoot: payload.repoRoot,
+            contractId: selected,
+            includeDirty: payload.includeDirty,
+            materializeConflict: payload.materializeConflict,
+            ...(payload.message === undefined
+                ? {}
+                : { message: payload.message }),
+        }
+        : null;
+}
+function decodeReview(id, payload) {
+    const valid = exactKeys(payload, [
+        "contractId",
+        "repoRoot",
+        "verdict",
+        ...(payload.summary === undefined ? [] : ["summary"]),
+    ]);
+    const selected = contractId(payload.contractId);
+    return valid
+        && selected !== null
+        && absolute(payload.repoRoot)
+        && (payload.verdict === "satisfied" || payload.verdict === "unsatisfied")
+        && (payload.summary === undefined
+            || (typeof payload.summary === "string"
+                && payload.summary.trim().length > 0))
+        ? {
+            id,
+            action: "contract.review",
+            repoRoot: payload.repoRoot,
+            contractId: selected,
+            verdict: payload.verdict,
+            ...(payload.summary === undefined
+                ? {}
+                : { summary: payload.summary }),
+        }
+        : null;
+}
+function decodeTask(id, action, payload) {
+    if (!isTaskMutationAction(action)
+        || !exactKeys(payload, ["request", "world"])
+        || !absolute(payload.world))
+        return null;
+    try {
+        return {
+            id,
+            action,
+            world: payload.world,
+            request: decodeTaskMutationRequest(action, payload.request),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+const CLAIM_DECODERS = {
+    "akuma.call": decodeCall,
+    "akuma.wait": decodeWait,
+    "akuma.tell": decodeTell,
+    "akuma.kill": decodeKill,
+    "contract.deliver": decodeDeliver,
+    "contract.review": decodeReview,
+};
+export function decodeClaim(bytes, fileId) {
+    let decoded;
+    try {
+        decoded = JSON.parse(bytes);
+    }
+    catch {
+        return null;
+    }
+    const value = object(decoded);
+    if (value === null
+        || !exactKeys(value, ["action", "id", "payload"])
+        || value.id !== fileId
+        || typeof value.id !== "string"
+        || !UUID.test(value.id))
+        return null;
+    const payload = object(value.payload);
+    if (payload === null || typeof value.action !== "string")
+        return null;
+    const decoder = CLAIM_DECODERS[value.action];
+    return decoder === undefined ? decodeTask(value.id, value.action, payload) : decoder(value.id, payload);
+}
+function outcome(value) {
+    const input = object(value);
+    if (input?.kind === "returned" && exactKeys(input, ["kind", "result"])) {
+        return { kind: input.kind, result: input.result };
+    }
+    const failure = object(input?.failure);
+    if (input?.kind !== "failed"
+        || !exactKeys(input, ["failure", "kind"])
+        || failure === null)
+        return null;
+    if (failure.kind === "akuma-not-born" && exactKeys(failure, ["id", "kind"])) {
+        const id = canonicalAkuId(failure.id);
+        return id === null
+            ? null
+            : { kind: input.kind, failure: { kind: failure.kind, id } };
+    }
+    return failure.kind === "failed" && exactKeys(failure, ["diagnostic", "kind"]) && typeof failure.diagnostic === "string"
+        ? { kind: input.kind, failure: { kind: failure.kind, diagnostic: failure.diagnostic } } : null;
+}
+function envelope(value, id, action) {
+    if (value.state === "refused"
+        && exactKeys(value, ["action", "diagnostic", "id", "state"])
+        && typeof value.diagnostic === "string") {
+        return { id, action, state: value.state, diagnostic: value.diagnostic };
+    }
+    if (value.state === "voided"
+        && exactKeys(value, ["action", "evidence", "id", "state"])
+        && typeof value.evidence === "string") {
+        return { id, action, state: value.state, evidence: value.evidence };
+    }
+    if (action !== "akuma.call"
+        && value.state === "served"
+        && exactKeys(value, ["action", "id", "outcome", "state"])) {
+        const decoded = outcome(value.outcome);
+        return decoded === null
+            ? null
+            : { id, action, state: value.state, outcome: decoded };
+    }
+    return null;
+}
+function reference(value, action) {
+    const input = object(value);
+    const field = action === "contract.deliver" ? "deliveryFactId" : "reviewFactId";
+    if (input === null
+        || !exactKeys(input, ["contractId", field, "kind", "repoRoot"])
+        || input.kind !== "accepted-reference"
+        || !absolute(input.repoRoot)
+        || contractId(input.contractId) === null
+        || typeof input[field] !== "string"
+        || input[field].trim().length === 0)
+        return null;
+    return action === "contract.deliver"
+        ? { kind: input.kind, repoRoot: input.repoRoot, contractId: input.contractId, deliveryFactId: input.deliveryFactId }
+        : { kind: input.kind, repoRoot: input.repoRoot, contractId: input.contractId, reviewFactId: input.reviewFactId };
+}
+function decodeCallReceipt(value, id) {
+    if (value.state !== "served" || !exactKeys(value, ["action", "child", "id", "state"]))
+        return null;
+    const child = canonicalAkuId(value.child);
+    return child === null ? null : { id, action: "akuma.call", state: value.state, child };
+}
+function decodeContractReceipt(value, id, action) {
+    if (value.state !== "served" || !exactKeys(value, ["action", "id", "reference", "state"]))
+        return null;
+    const selected = reference(value.reference, action);
+    if (selected === null)
+        return null;
+    return action === "contract.deliver"
+        ? { id, action, state: value.state, reference: selected }
+        : { id, action, state: value.state, reference: selected };
+}
+function decodeTaskReceipt(value, id, action) {
+    if (value.state !== "served" || !exactKeys(value, ["action", "id", "reference", "state"]))
+        return null;
+    const selected = object(value.reference);
+    if (selected === null
+        || !exactKeys(selected, ["action", "kind"])
+        || selected.kind !== "served-reference"
+        || selected.action !== action)
+        return null;
+    return { id, action, state: value.state, reference: { kind: selected.kind, action } };
+}
+export function decodeReceipt(bytes, id, action) {
+    let decoded;
+    try {
+        decoded = JSON.parse(bytes);
+    }
+    catch {
+        return null;
+    }
+    const value = object(decoded);
+    if (value === null || value.id !== id || value.action !== action)
+        return null;
+    const shared = envelope(value, id, action);
+    if (shared !== null)
+        return shared;
+    if (action === "akuma.call")
+        return decodeCallReceipt(value, id);
+    if (action === "contract.deliver" || action === "contract.review")
+        return decodeContractReceipt(value, id, action);
+    if (isTaskMutationAction(action))
+        return decodeTaskReceipt(value, id, action);
+    return null;
+}
+export function requestPayload(claim) {
+    if (isTaskMutationAction(claim.action)) {
+        const task = claim;
+        const { action: _action, ...request } = task.request;
+        return { world: task.world, request };
+    }
+    const { id: _id, action: _action, ...payload } = claim;
+    return payload;
+}
+export function requestPath(directory, id) {
+    return join(directory, `${id}.request.json`);
+}
+export function receiptPath(directory, id) {
+    return join(directory, `${id}.receipt.json`);
+}
+export async function atomicJson(path, value) {
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, `${JSON.stringify(value)}\n`, { flag: "wx" });
+        await rename(temporary, path);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}

package/build/src/akuma/requests.d.ts

@@ -1,71 +1,6 @@
-import { type KillEvidence, type RequestRecipe, type Soul } from "./heart/index.js";
-import { type AkuId, type AkumaPaths } from "./identity.js";
-type RequestClaimRecipe = Omit<RequestRecipe, "confinement">;
-type CallRequestClaim = Readonly<{
-    id: string;
-    action: "akuma.call";
-    world: string;
-    archetype: string;
-    body: string;
-    cwd?: string;
-    recipe: RequestClaimRecipe;
-}>;
-type WaitRequestClaim = Readonly<{
-    id: string;
-    action: "akuma.wait";
-    targets: readonly AkuId[];
-    completion: "any" | "all";
-    timeoutMs?: number;
-}>;
-type TellRequestClaim = Readonly<{
-    id: string;
-    action: "akuma.tell";
-    target: AkuId;
-    body: string;
-}>;
-type KillRequestClaim = Readonly<{
-    id: string;
-    action: "akuma.kill";
-    targets: readonly AkuId[];
-}>;
-type UpstreamRequestFailure = Readonly<{
-    kind: "akuma-not-born";
-    id: AkuId;
-}> | Readonly<{
-    kind: "failed";
-    diagnostic: string;
-}>;
-export type UpstreamRequestOutcome = Readonly<{
-    kind: "returned";
-    result: unknown;
-}> | Readonly<{
-    kind: "failed";
-    failure: UpstreamRequestFailure;
-}>;
-export type UpstreamExecutionPort = Readonly<{
-    wait(input: Omit<WaitRequestClaim, "id" | "action"> & Readonly<{
-        signal: AbortSignal;
-    }>): Promise<unknown>;
-    tell(input: Omit<TellRequestClaim, "id" | "action"> & Readonly<{
-        tellId: string;
-        recordedAt: string;
-        signal: AbortSignal;
-    }>): Promise<unknown>;
-    kill(input: Omit<KillRequestClaim, "id" | "action"> & Readonly<{
-        signal: AbortSignal;
-    }>): Promise<Readonly<{
-        result: unknown;
-        service: readonly Readonly<{
-            id: AkuId;
-            evidence: KillEvidence;
-        }>[];
-    }>>;
-}>;
-export type RequestChildLaunch = Readonly<{
-    paths: AkumaPaths;
-    seed: Omit<Soul, "createdAt">;
-    initialBody: string;
-}>;
+import { type CallRequestClaim, type DeliverRequestClaim, type ForwardedDeliveryReference, type ForwardedReviewReference, type KillRequestClaim, type ReviewRequestClaim, type TellRequestClaim, type UpstreamRequestOutcome, type WaitRequestClaim } from "./request-wire.js";
+import { type TaskMutationRequest } from "../task/mutation.js";
+export type { UpstreamRequestOutcome } from "./request-wire.js";
 export declare class AkumaBodyRequestError extends Error {
     readonly outcome: "refused" | "voided";
     readonly diagnostic: string;
@@ -75,7 +10,13 @@ export declare class AkumaBodyRequestError extends Error {
 export declare function injectedBodyRequests(): string | null;
 export declare function requestBodyCall(input: Omit<CallRequestClaim, "action"> & Readonly<{
     directory: string;
-}>): Promise<AkuId>;
+}>): Promise<import("./identity.js").AkuId>;
+export declare function requestBodyTask(input: Readonly<{
+    directory: string;
+    world: string;
+    request: TaskMutationRequest;
+    id?: string;
+}>): Promise<unknown>;
 export declare function requestBodyWait(input: Omit<WaitRequestClaim, "action" | "id"> & Readonly<{
     directory: string;
     id?: string;
@@ -88,28 +29,21 @@ export declare function requestBodyKill(input: Omit<KillRequestClaim, "action" |
     directory: string;
     id?: string;
 }>): Promise<UpstreamRequestOutcome>;
-export declare class BodyRequestPump {
-    private readonly input;
-    readonly directory: string;
-    readonly failure: Promise<never>;
-    private readonly closeSignal;
-    private readonly handled;
-    private readonly running;
-    private readonly cancelAdmission;
-    private constructor();
-    static open(input: Readonly<{
-        paths: AkumaPaths;
-        parent: Soul;
-        bodySequence: number;
-        now(): string;
-        spawn(launch: RequestChildLaunch): Promise<void>;
-        upstream?: UpstreamExecutionPort;
-        signal: AbortSignal;
-    }>): Promise<BodyRequestPump>;
-    private run;
-    close(): Promise<void>;
-    stopAdmission(): void;
-}
-export declare function clearBodyRequestTransport(paths: AkumaPaths): Promise<void>;
-export declare function settleBodyRequests(paths: AkumaPaths, parent: Soul, now: () => string, signal?: AbortSignal): Promise<"settled" | "pending">;
-export {};
+type ContractRequestInput<T extends DeliverRequestClaim | ReviewRequestClaim> = Omit<T, "action" | "id"> & Readonly<{
+    directory: string;
+    signal?: AbortSignal;
+}>;
+type BodyDeliverInput = ContractRequestInput<DeliverRequestClaim>;
+export declare function requestBodyDeliver(input: BodyDeliverInput & Readonly<{
+    id?: never;
+}>): Promise<UpstreamRequestOutcome>;
+export declare function requestBodyDeliver(input: BodyDeliverInput & Readonly<{
+    id: string;
+}>): Promise<UpstreamRequestOutcome | ForwardedDeliveryReference>;
+type BodyReviewInput = ContractRequestInput<ReviewRequestClaim>;
+export declare function requestBodyReview(input: BodyReviewInput & Readonly<{
+    id?: never;
+}>): Promise<UpstreamRequestOutcome>;
+export declare function requestBodyReview(input: BodyReviewInput & Readonly<{
+    id: string;
+}>): Promise<UpstreamRequestOutcome | ForwardedReviewReference>;