@astrosheep/keiyaku 4.0.3 → 4.0.5

package/build/src/akuma/requests.js

@@ -1,15 +1,10 @@
 import { randomUUID } from "node:crypto";
-import { access, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
-import { isAbsolute, join, resolve } from "node:path";
-import { HeldAkumaLeash, admitRequest, readNonterminalRequests, readRequest, readSoul, refuseRequest, reserveRequest, serveRequest, voidRequest, } from "./heart/index.js";
-import { parseAkuId, pathsForAkuId, archetypeName, worldRootForAkumaPaths, } from "./identity.js";
-import { BIRTH_TIMEOUT_MS, publishAkuma } from "./publication.js";
+import { access, readFile } from "node:fs/promises";
 import { abortableDelay } from "./abort.js";
 import { AKUMA_REQUESTS_ENV } from "./provider.js";
-import { decodeProviderOptions, decodeReadonlyRestraint } from "./provider-recipe.js";
-import { resolveProviderExecution } from "./providers/index.js";
+import { absolute, atomicJson, decodeReceipt, receiptPath, requestPath, requestPayload, } from "./request-wire.js";
+import { isTaskMutationAction } from "../task/mutation.js";
 const POLL_MS = 25;
-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;
 export class AkumaBodyRequestError extends Error {
     outcome;
     diagnostic;
@@ -21,169 +16,6 @@ export class AkumaBodyRequestError extends Error {
         this.name = "AkumaBodyRequestError";
     }
 }
-function diagnostic(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-function exactKeys(value, expected) {
-    const actual = Object.keys(value).sort();
-    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
-}
-function absolute(value) {
-    return typeof value === "string" && isAbsolute(value) && resolve(value) === value;
-}
-function matchingConfinement(value, expected) {
-    const confinement = object(value);
-    if (confinement === null || confinement.kind !== expected.kind)
-        return false;
-    if (expected.kind === "unconfined")
-        return exactKeys(confinement, ["kind"]);
-    if (!exactKeys(confinement, ["kind", "writableRoots"]) || !Array.isArray(confinement.writableRoots))
-        return false;
-    return confinement.writableRoots.length === expected.writableRoots.length
-        && confinement.writableRoots.every((root, index) => root === expected.writableRoots[index]);
-}
-function decodeRecipe(value, cwd) {
-    const recipe = object(value);
-    if (recipe === null)
-        return null;
-    const expectedKeys = [
-        "confinement",
-        ...(recipe.description === undefined ? [] : ["description"]),
-        "options",
-        "provider",
-        ...(recipe.readonly === undefined ? [] : ["readonly"]),
-    ];
-    if (!exactKeys(recipe, expectedKeys))
-        return null;
-    if (recipe.description !== undefined
-        && (typeof recipe.description !== "string" || recipe.description.trim().length === 0))
-        return null;
-    try {
-        const selected = resolveProviderExecution(recipe.provider);
-        const provider = selected.execution;
-        const adapter = selected.adapter;
-        const decodedOptions = decodeProviderOptions(recipe.options);
-        const readonly = recipe.readonly === undefined ? undefined : decodeReadonlyRestraint(recipe.readonly);
-        if ((decodedOptions.readonly === true) !== (readonly !== undefined))
-            return null;
-        const confinement = adapter.confinement({ cwd, options: decodedOptions });
-        if (!matchingConfinement(recipe.confinement, confinement))
-            return null;
-        return Object.freeze({
-            ...(recipe.description === undefined ? {} : { description: recipe.description }),
-            provider,
-            options: decodedOptions,
-            ...(readonly === undefined ? {} : { readonly }),
-            confinement,
-        });
-    }
-    catch {
-        return null;
-    }
-}
-function decodeClaim(bytes, fileId) {
-    let decoded;
-    try {
-        decoded = JSON.parse(bytes);
-    }
-    catch {
-        return null;
-    }
-    const value = object(decoded);
-    if (value === null)
-        return null;
-    const expected = [
-        "archetype",
-        "body",
-        ...(value.cwd === undefined ? [] : ["cwd"]),
-        "id",
-        "recipe",
-        "world",
-    ];
-    if (!exactKeys(value, expected))
-        return null;
-    if (value.id !== fileId || typeof value.id !== "string" || !UUID.test(value.id))
-        return null;
-    if (typeof value.body !== "string" || !absolute(value.world))
-        return null;
-    if (value.cwd !== undefined && !absolute(value.cwd))
-        return null;
-    try {
-        archetypeName(value.archetype);
-    }
-    catch {
-        return null;
-    }
-    const recipe = decodeRecipe(value.recipe, (value.cwd ?? value.world));
-    if (recipe === null)
-        return null;
-    return {
-        id: value.id,
-        world: value.world,
-        archetype: value.archetype,
-        body: value.body,
-        recipe,
-        ...(value.cwd === undefined ? {} : { cwd: value.cwd }),
-    };
-}
-function decodeReceipt(bytes, requestId) {
-    let decoded;
-    try {
-        decoded = JSON.parse(bytes);
-    }
-    catch {
-        return null;
-    }
-    const value = object(decoded);
-    if (value === null || value.id !== requestId)
-        return null;
-    if (value.state === "served" && exactKeys(value, ["child", "id", "state"])) {
-        try {
-            return { id: requestId, state: "served", child: parseAkuId(value.child).id };
-        }
-        catch {
-            return null;
-        }
-    }
-    if (value.state === "refused" && exactKeys(value, ["diagnostic", "id", "state"])
-        && typeof value.diagnostic === "string") {
-        return { id: requestId, state: "refused", diagnostic: value.diagnostic };
-    }
-    if (value.state === "voided" && exactKeys(value, ["evidence", "id", "state"])
-        && typeof value.evidence === "string") {
-        return { id: requestId, state: "voided", evidence: value.evidence };
-    }
-    return null;
-}
-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 });
-    }
-}
-function receiptFor(fact) {
-    if (fact.state === "served")
-        return { id: fact.id, state: fact.state, child: fact.child };
-    if (fact.state === "refused")
-        return { id: fact.id, state: fact.state, diagnostic: fact.diagnostic };
-    if (fact.state === "voided")
-        return { id: fact.id, state: fact.state, evidence: fact.evidence };
-    return null;
-}
-async function projectReceipt(directory, fact) {
-    const receipt = receiptFor(fact);
-    if (receipt !== null)
-        await atomicJson(join(directory, `${fact.id}.receipt.json`), receipt);
-}
 export function injectedBodyRequests() {
     const directory = process.env[AKUMA_REQUESTS_ENV];
     if (directory === undefined)
@@ -192,227 +24,96 @@ export function injectedBodyRequests() {
         throw new Error(`${AKUMA_REQUESTS_ENV} must be an absolute normalized path`);
     return directory;
 }
-export async function requestBodyCall(input) {
-    await atomicJson(join(input.directory, `${input.id}.request.json`), {
-        id: input.id,
-        world: input.world,
-        archetype: input.archetype,
-        body: input.body,
-        recipe: input.recipe,
-        ...(input.cwd === undefined ? {} : { cwd: input.cwd }),
+async function requestBody(input) {
+    input.signal?.throwIfAborted();
+    await atomicJson(requestPath(input.directory, input.claim.id), {
+        id: input.claim.id,
+        action: input.claim.action,
+        payload: requestPayload(input.claim),
     });
-    const receiptPath = join(input.directory, `${input.id}.receipt.json`);
+    const path = receiptPath(input.directory, input.claim.id);
     for (;;) {
         try {
-            const receipt = decodeReceipt(await readFile(receiptPath, "utf8"), input.id);
+            const receipt = decodeReceipt(await readFile(path, "utf8"), input.claim.id, input.claim.action);
             if (receipt === null)
-                throw new Error(`Akuma body request ${input.id} has an invalid receipt`);
-            if (receipt.state === "served")
-                return receipt.child;
+                throw new Error(`Akuma body request ${input.claim.id} has an invalid receipt`);
             if (receipt.state === "refused")
                 throw new AkumaBodyRequestError("refused", receipt.diagnostic);
-            throw new AkumaBodyRequestError("voided", receipt.evidence);
+            if (receipt.state === "voided")
+                throw new AkumaBodyRequestError("voided", receipt.evidence);
+            return receipt;
         }
         catch (error) {
             if (error.code !== "ENOENT")
                 throw error;
         }
-        await abortableDelay(POLL_MS);
+        if (!await access(input.directory).then(() => true, () => false)) {
+            throw new AkumaBodyRequestError("voided", "parent request channel closed before a receipt");
+        }
+        await abortableDelay(POLL_MS, input.signal);
     }
 }
-async function serveClaim(input) {
-    input.signal.throwIfAborted();
-    let fact = await admitRequest(input.paths, { ...input.claim, admittedAt: input.now() });
-    const existing = receiptFor(fact);
-    if (existing !== null) {
-        if (!input.signal.aborted)
-            await projectReceipt(input.directory, fact);
-        return;
-    }
-    if (fact.state !== "admitted")
-        throw new Error(`Akuma request ${fact.id} cannot be replayed from ${fact.state}`);
-    const request = fact;
-    const servingWorld = worldRootForAkumaPaths(input.paths);
-    if (request.world !== servingWorld) {
-        fact = await refuseRequest(input.paths, request.id, `request world ${request.world} does not match ${servingWorld}`);
-        await projectReceipt(input.directory, fact);
-        return;
-    }
-    const cwd = resolve(request.cwd ?? servingWorld);
-    let child;
-    try {
-        input.signal.throwIfAborted();
-        const published = await publishAkuma({
-            worldPath: servingWorld,
-            archetype: request.archetype,
-            reserve: async (allocated) => { fact = await reserveRequest(input.paths, request.id, allocated.id); },
-            signal: input.signal,
-            launch: async (allocated) => await input.spawn({
-                paths: allocated.paths,
-                seed: {
-                    id: allocated.id,
-                    archetype: allocated.archetype,
-                    ...(request.recipe.description === undefined ? {} : { description: request.recipe.description }),
-                    provider: request.recipe.provider,
-                    options: request.recipe.options,
-                    ...(request.recipe.readonly === undefined ? {} : { readonly: request.recipe.readonly }),
-                    cwd,
-                    origin: { kind: "request", parent: input.parent.id, requestId: request.id },
-                    confinement: request.recipe.confinement,
-                },
-                initialBody: request.body,
-            }),
-        });
-        child = published.id;
-    }
-    catch (error) {
-        if (input.signal.aborted)
-            return;
-        const current = await readRequest(input.paths, request.id);
-        if (current === null)
-            throw error;
-        fact = current.state === "admitted" || current.state === "reserved"
-            ? await voidRequest(input.paths, request.id, diagnostic(error))
-            : current;
-        await projectReceipt(input.directory, fact);
-        return;
+export async function requestBodyCall(input) {
+    const { directory, ...claim } = input;
+    const receipt = await requestBody({ directory, claim: { ...claim, action: "akuma.call" } });
+    if (receipt.action !== "akuma.call" || receipt.state !== "served") {
+        throw new Error(`Akuma body request ${input.id} returned the wrong action`);
     }
-    fact = await serveRequest(input.paths, request.id, child);
-    await projectReceipt(input.directory, fact);
+    return receipt.child;
 }
-async function requestFiles(directory) {
-    try {
-        return (await readdir(directory))
-            .filter((name) => name.endsWith(".request.json"))
-            .sort();
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
+async function requestUpstream(directory, claim, signal) {
+    const receipt = await requestBody({ directory, claim, ...(signal === undefined ? {} : { signal }) });
+    if (receipt.action === "akuma.call" || receipt.state !== "served" || !("outcome" in receipt)) {
+        throw new Error(`Akuma body request ${claim.id} returned the wrong action`);
     }
+    return receipt.outcome;
 }
-export class BodyRequestPump {
-    input;
-    directory;
-    failure;
-    closeSignal = new AbortController();
-    handled = new Set();
-    running;
-    cancelAdmission;
-    constructor(input) {
-        this.input = input;
-        this.directory = join(input.paths.directory, "requests", String(input.bodySequence));
-        this.cancelAdmission = () => this.stopAdmission();
-        input.signal.addEventListener("abort", this.cancelAdmission, { once: true });
-        if (input.signal.aborted)
-            this.cancelAdmission();
-        this.running = this.run();
-        this.failure = this.running.then(() => new Promise(() => { }), (error) => Promise.reject(error));
-    }
-    static async open(input) {
-        const directory = join(input.paths.directory, "requests", String(input.bodySequence));
-        await mkdir(directory, { recursive: true });
-        return new BodyRequestPump(input);
-    }
-    async run() {
-        while (!this.closeSignal.signal.aborted) {
-            for (const name of await requestFiles(this.directory)) {
-                if (this.closeSignal.signal.aborted)
-                    return;
-                const id = name.slice(0, -".request.json".length);
-                if (this.handled.has(id))
-                    continue;
-                const claim = decodeClaim(await readFile(join(this.directory, name), "utf8"), id);
-                if (claim === null) {
-                    this.handled.add(id);
-                    continue;
-                }
-                await serveClaim({ directory: this.directory, claim, ...this.input, signal: this.closeSignal.signal });
-                this.handled.add(id);
-            }
-            try {
-                await abortableDelay(POLL_MS, this.closeSignal.signal);
-            }
-            catch {
-                return;
-            }
-        }
-    }
-    async close() {
-        this.stopAdmission();
-        try {
-            await this.running;
-        }
-        finally {
-            this.input.signal.removeEventListener("abort", this.cancelAdmission);
-            await rm(this.directory, { recursive: true, force: true });
-        }
-    }
-    stopAdmission() {
-        if (!this.closeSignal.signal.aborted)
-            this.closeSignal.abort(new Error("Body request pump closed"));
+export async function requestBodyTask(input) {
+    const id = input.id ?? randomUUID();
+    const receipt = await requestBody({
+        directory: input.directory,
+        claim: { id, action: input.request.action, world: input.world, request: input.request },
+    });
+    if (!isTaskMutationAction(receipt.action) || receipt.action !== input.request.action || receipt.state !== "served") {
+        throw new Error(`Akuma body request ${id} returned the wrong action`);
+    }
+    if ("reference" in receipt)
+        return receipt.reference;
+    if (receipt.outcome.kind === "returned")
+        return receipt.outcome.result;
+    throw new Error(receipt.outcome.failure.kind === "failed"
+        ? receipt.outcome.failure.diagnostic
+        : "Akuma body request parent is not born");
+}
+export async function requestBodyWait(input) {
+    const { directory, id = randomUUID(), ...claim } = input;
+    return await requestUpstream(directory, { ...claim, id, action: "akuma.wait" });
+}
+export async function requestBodyTell(input) {
+    const { directory, id = randomUUID(), ...claim } = input;
+    return await requestUpstream(directory, { ...claim, id, action: "akuma.tell" });
+}
+export async function requestBodyKill(input) {
+    const { directory, id = randomUUID(), ...claim } = input;
+    return await requestUpstream(directory, { ...claim, id, action: "akuma.kill" });
+}
+async function requestContract(input, action) {
+    const { directory, id = randomUUID(), signal, ...claim } = input;
+    const receipt = await requestBody({
+        directory,
+        claim: { ...claim, id, action },
+        ...(signal === undefined ? {} : { signal }),
+    });
+    if (receipt.action !== action || receipt.state !== "served") {
+        throw new Error(`Akuma body request ${id} returned the wrong action`);
     }
+    return "reference" in receipt
+        ? receipt.reference
+        : receipt.outcome;
 }
-export async function clearBodyRequestTransport(paths) {
-    await rm(join(paths.directory, "requests"), { recursive: true, force: true });
-}
-function matchingRequestOrigin(soul, parent, requestId) {
-    return soul.origin.kind === "request"
-        && soul.origin.parent === parent
-        && soul.origin.requestId === requestId;
-}
-async function settleObservedSoul(paths, parent, request, soul) {
-    if (matchingRequestOrigin(soul, parent.id, request.id))
-        await serveRequest(paths, request.id, request.child);
-    else
-        await voidRequest(paths, request.id, "reserved child origin does not match the request");
+export async function requestBodyDeliver(input) {
+    return await requestContract(input, "contract.deliver");
 }
-async function settleReserved(paths, parent, request, now, signal) {
-    const childPaths = pathsForAkuId(request.world, request.child);
-    const deadline = performance.now() + BIRTH_TIMEOUT_MS;
-    for (;;) {
-        signal?.throwIfAborted();
-        if (!await access(childPaths.directory).then(() => true, () => false)) {
-            await voidRequest(paths, request.id, "reserved child directory is absent");
-            return true;
-        }
-        const childSoul = await readSoul(childPaths);
-        if (childSoul !== null) {
-            await settleObservedSoul(paths, parent, request, childSoul);
-            return true;
-        }
-        const leash = await HeldAkumaLeash.try(childPaths);
-        if (leash !== null) {
-            try {
-                const settledSoul = await readSoul(childPaths);
-                if (settledSoul !== null) {
-                    await settleObservedSoul(paths, parent, request, settledSoul);
-                }
-                else {
-                    await leash.sealIfUnborn(childPaths, { evidence: "request settlement", at: now() });
-                    await voidRequest(paths, request.id, "reserved child was sealed unborn");
-                }
-            }
-            finally {
-                leash.release();
-            }
-            return true;
-        }
-        if (performance.now() >= deadline)
-            return false;
-        await abortableDelay(POLL_MS, signal);
-    }
-}
-export async function settleBodyRequests(paths, parent, now, signal) {
-    let pending = false;
-    for (const request of await readNonterminalRequests(paths)) {
-        signal?.throwIfAborted();
-        if (request.state === "admitted") {
-            await voidRequest(paths, request.id, "body died before serving the request");
-        }
-        else if (request.state === "reserved" && !await settleReserved(paths, parent, request, now, signal))
-            pending = true;
-    }
-    return pending ? "pending" : "settled";
+export async function requestBodyReview(input) {
+    return await requestContract(input, "contract.review");
 }

package/build/src/akuma-body.d.ts

@@ -0,0 +1,8 @@
+import { type BodyLaunch } from "./akuma/body.js";
+import type { UpstreamExecutionPort } from "./akuma/request-serve.js";
+type BodyProcessConfiguration = Readonly<{
+    home?: string;
+    gitPath?: string;
+}>;
+export declare function upstreamFor(launch: BodyLaunch, processConfiguration: BodyProcessConfiguration): UpstreamExecutionPort;
+export {};

package/build/src/akuma-body.js

@@ -0,0 +1,84 @@
+import { runAkumaBody } from "./akuma/body.js";
+import { worldRootForAkumaPaths } from "./akuma/identity.js";
+import { executeKillAkuma, executeTellAkuma, executeWaitAkuma, } from "./library/fleet.js";
+import { requireBranchesToBeUpToDateFrom, worktreeHooksFrom, } from "./library/configuration.js";
+import { executeForwardedDeliver, executeForwardedReview, } from "./library/contract.js";
+import { Repo } from "./library/repo.js";
+import { settings } from "./settings.js";
+import { executeTaskMutation } from "./task/mutation.js";
+export function upstreamFor(launch, processConfiguration) {
+    const path = worldRootForAkumaPaths(launch.paths);
+    return {
+        wait: async (input) => await executeWaitAkuma({
+            path,
+            ids: input.targets,
+            completion: input.completion,
+            ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+            signal: input.signal,
+        }),
+        tell: async (input) => await executeTellAkuma({
+            path,
+            id: input.target,
+            body: input.body,
+            tellId: input.tellId,
+            recordedAt: input.recordedAt,
+            signal: input.signal,
+        }),
+        kill: async (input) => {
+            const result = await executeKillAkuma({ path, ids: input.targets, signal: input.signal });
+            return {
+                result,
+                service: result.results.map(({ id, evidence }) => ({ id, evidence })),
+            };
+        },
+        deliver: async (input) => {
+            const [repo, configuration] = await Promise.all([
+                Repo.at({
+                    path: input.repoRoot,
+                    ...(processConfiguration.gitPath === undefined ? {} : { gitPath: processConfiguration.gitPath }),
+                }),
+                settings({
+                    root: input.repoRoot,
+                    ...(processConfiguration.home === undefined ? {} : { home: processConfiguration.home }),
+                }),
+            ]);
+            return await executeForwardedDeliver({
+                repo,
+                contractId: input.contractId,
+                requester: input.requester,
+                ...(input.message === undefined ? {} : { message: input.message }),
+                includeDirty: input.includeDirty,
+                requireBranchesToBeUpToDate: requireBranchesToBeUpToDateFrom({ settings: configuration }),
+                hooks: worktreeHooksFrom({ settings: configuration }),
+                signal: input.signal,
+            });
+        },
+        review: async (input) => {
+            const [repo, configuration] = await Promise.all([
+                Repo.at({
+                    path: input.repoRoot,
+                    ...(processConfiguration.gitPath === undefined ? {} : { gitPath: processConfiguration.gitPath }),
+                }),
+                settings({
+                    root: input.repoRoot,
+                    ...(processConfiguration.home === undefined ? {} : { home: processConfiguration.home }),
+                }),
+            ]);
+            return await executeForwardedReview({
+                repo,
+                contractId: input.contractId,
+                requester: input.requester,
+                verdict: input.verdict,
+                ...(input.summary === undefined ? {} : { summary: input.summary }),
+                hooks: worktreeHooksFrom({ settings: configuration }),
+            });
+        },
+        task: async (input) => await executeTaskMutation({
+            world: input.world,
+            request: input.request,
+            requester: input.requester,
+            signal: input.signal,
+        }),
+    };
+}
+await runAkumaBody(upstreamFor);

package/build/src/body/arc.js

@@ -1,15 +1,8 @@
-import { parseToAST } from "../markdown/parse.js";
-import { indexDocument, indexedHeadings, normalizeTitle, rawSlice, sectionContent, } from "../markdown/query.js";
+import { sectionContent } from "../markdown/query.js";
+import { decodeDocumentEnvelope } from "./envelope.js";
 function refusal(message) {
     throw new TypeError(message);
 }
-function nonblankRaw(document, node) {
-    return rawSlice(document, node.span).trim().length > 0;
-}
-function topLevelSections(document) {
-    return indexedHeadings(indexDocument(document), { level: 2 })
-        .filter((node) => node.type === "section");
-}
 function requiredProse(document, sections, name) {
     const section = sections.get(name);
     if (section === undefined)
@@ -20,31 +13,13 @@ function requiredProse(document, sections, name) {
     return value;
 }
 export function decodeArcDocument(source) {
-    const document = parseToAST(source);
-    if (document.frontmatter !== undefined)
-        refusal("arc document may not contain frontmatter");
-    const titles = indexedHeadings(indexDocument(document), { level: 1 })
-        .filter((node) => node.type === "section");
-    if (titles.length !== 1)
-        refusal("arc document requires exactly one H1 title");
-    const title = titles[0];
+    const { document, title, sections } = decodeDocumentEnvelope(source, "arc");
     if (title.title.trim().length === 0)
         refusal("arc title must be nonblank");
-    if (title.children.some((node) => nonblankRaw(document, node))) {
-        refusal("arc title may not contain content before the first H2 section");
-    }
-    const stray = document.children.filter((node) => node.type !== "section" && nonblankRaw(document, node));
-    if (stray.length > 0)
-        refusal("arc document contains content outside an H1 or H2 section");
-    const sections = new Map();
-    for (const section of topLevelSections(document)) {
-        const name = normalizeTitle(section.title);
-        if (sections.has(name))
-            refusal(`duplicate arc section '${section.title}'`);
+    for (const [name, section] of sections) {
         if (name !== "objective" && name !== "brief") {
             refusal(`arc document does not allow ## ${section.title}`);
         }
-        sections.set(name, section);
     }
     return {
         title: title.title,