@astrosheep/keiyaku 4.0.5 → 4.0.6

package/build/src/akuma/body-turn.js

@@ -0,0 +1,449 @@
+import { abortableDelay } from "./abort.js";
+import { appendActivity, beginTurn, breakBody, heartExists, readHeart, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
+import { encodeAgentEvent, } from "./provider.js";
+import { BodyRequestPump, } from "./request-serve.js";
+const BODY_CONTROL_OBSERVATION_MS = 100;
+export const CONTROL_RESPONSE_MS = 1_000;
+export class BodySupervisor {
+    paths;
+    bodySequence;
+    leash;
+    signal;
+    controller = new AbortController();
+    finished = new AbortController();
+    observer;
+    waiter;
+    observation;
+    stopping;
+    constructor(paths, bodySequence, leash, observation) {
+        this.paths = paths;
+        this.bodySequence = bodySequence;
+        this.leash = leash;
+        this.signal = this.controller.signal;
+        this.observation = observation;
+        this.observer = this.observe();
+    }
+    static async open(paths, bodySequence, leash) {
+        return new BodySupervisor(paths, bodySequence, leash, await readHeart(paths));
+    }
+    get reason() { return this.stopping; }
+    current() { return this.observation; }
+    async recordHung(diagnostic, at) {
+        await this.leash.recordBodyHung(this.paths, { sequence: this.bodySequence, diagnostic, at });
+    }
+    async refresh() {
+        this.publish(await readHeart(this.paths));
+        return this.observation;
+    }
+    next(after) {
+        if (this.observation !== after)
+            return Promise.resolve(this.observation);
+        return new Promise((resolve) => { this.waiter = resolve; });
+    }
+    cancel(reason) {
+        if (this.stopping !== undefined)
+            return;
+        this.stopping = reason;
+        this.controller.abort(new Error(reason === "control"
+            ? "Akuma Body interrupted by durable control"
+            : "Akuma Heart disappeared"));
+        this.waiter?.(this.observation);
+        this.waiter = undefined;
+    }
+    async close() {
+        this.finished.abort();
+        await this.observer;
+        this.waiter = undefined;
+    }
+    publish(snapshot) {
+        this.observation = snapshot;
+        this.waiter?.(snapshot);
+        this.waiter = undefined;
+    }
+    async observe() {
+        for (;;) {
+            const snapshot = this.observation;
+            if (!await heartExists(this.paths))
+                return this.cancel("heart-gone");
+            if (snapshot.stop?.bodySequence === this.bodySequence || snapshot.pause?.bodySequence === this.bodySequence) {
+                return this.cancel("control");
+            }
+            try {
+                await abortableDelay(BODY_CONTROL_OBSERVATION_MS, this.finished.signal);
+            }
+            catch {
+                return;
+            }
+            try {
+                await this.refresh();
+            }
+            catch (error) {
+                if (await heartExists(this.paths))
+                    throw error;
+                return this.cancel("heart-gone");
+            }
+        }
+    }
+}
+function serializeEffects() {
+    let tail = Promise.resolve();
+    let failed = false;
+    let failure;
+    const serialize = async (effect) => {
+        const result = tail.then(effect);
+        tail = result.then(() => undefined, (error) => {
+            if (!failed)
+                failure = error;
+            failed = true;
+        });
+        return await result;
+    };
+    serialize.drain = async () => {
+        await tail;
+        if (failed)
+            throw failure;
+    };
+    return serialize;
+}
+export async function turnRecipe(paths, soul) {
+    const latest = (await readHeart(paths)).latestSession;
+    const admitted = latest?.provider === soul.provider.name ? latest : undefined;
+    const session = admitted?.coordinate;
+    return {
+        cwd: admitted?.cwd ?? soul.cwd,
+        options: admitted?.options ?? soul.options,
+        ...(session === undefined ? {} : { session }),
+    };
+}
+async function failedTurnSetup(input, turnSequence, requests, cancelDrive, error) {
+    try {
+        await requests.close();
+    }
+    catch { /* Preserve the setup or pump failure. */ }
+    input.supervisor.signal.removeEventListener("abort", cancelDrive);
+    if (input.supervisor.signal.aborted) {
+        if (input.supervisor.reason === "heart-gone")
+            throw error;
+        return { kind: "stopped" };
+    }
+    return {
+        kind: "failed",
+        turnSequence,
+        diagnostic: error instanceof Error ? error.message : String(error),
+    };
+}
+async function writeProviderEvent(input, active, event) {
+    if (input.supervisor.signal.aborted)
+        return;
+    const at = input.now();
+    if (event.type === "session") {
+        await recordSession(input.paths, {
+            provider: input.soul.provider.name,
+            coordinate: event.coordinate,
+            cwd: active.cwd,
+            options: active.options,
+            admittedAt: at,
+        });
+    }
+    await appendActivity(input.paths, {
+        turnSequence: active.turnSequence,
+        event: encodeAgentEvent(event),
+        at,
+    });
+}
+async function startTurnDrive(input) {
+    const { cwd, options, session } = await turnRecipe(input.paths, input.soul);
+    if (session !== undefined && input.adapter.resume === undefined)
+        return { kind: "resume-unsupported" };
+    const turn = await beginTurn(input.paths, {
+        bodySequence: input.bodySequence,
+        startedAt: input.now(),
+        ...(input.call === undefined ? {} : { call: input.call }),
+    });
+    const requests = await BodyRequestPump.open({
+        paths: input.paths,
+        parent: input.soul,
+        bodySequence: input.bodySequence,
+        now: input.now,
+        spawn: input.runtimeSpawn,
+        ...(input.upstream === undefined ? {} : { upstream: input.upstream }),
+        signal: input.supervisor.signal,
+    });
+    const driveController = new AbortController();
+    const cancelDrive = () => {
+        if (!driveController.signal.aborted)
+            driveController.abort(input.supervisor.signal.reason);
+    };
+    input.supervisor.signal.addEventListener("abort", cancelDrive, { once: true });
+    if (input.supervisor.signal.aborted)
+        cancelDrive();
+    void requests.failure.catch((error) => {
+        if (!driveController.signal.aborted)
+            driveController.abort(error);
+    });
+    const driveInput = {
+        body: input.body,
+        launchTells: input.launchTells.map((tell) => ({ id: tell.id, text: tell.body })),
+        cwd,
+        options,
+        signal: driveController.signal,
+        requests: { dir: requests.directory },
+    };
+    const setup = session === undefined
+        ? input.adapter.start({ ...driveInput, session: { kind: "fresh" } })
+        : input.adapter.resume({ ...driveInput, session: { kind: "resume", coordinate: session } });
+    try {
+        const selected = await Promise.race([setup, requests.failure]);
+        if (input.supervisor.signal.aborted) {
+            try {
+                const retirement = await retireProviderCustody(input, turn.sequence, selected);
+                await requests.close();
+                if (retirement.kind === "hung")
+                    return retirement;
+            }
+            finally {
+                input.supervisor.signal.removeEventListener("abort", cancelDrive);
+            }
+            return { kind: "stopped" };
+        }
+        if (input.launchTells.length > 0) {
+            await recordTellDeliveries(input.paths, input.launchTells.map((tell) => ({
+                tellId: tell.id,
+                route: "launch",
+                turnSequence: turn.sequence,
+                fence: selected.admission.fence,
+                deliveredAt: input.now(),
+            })));
+        }
+        void selected.completion.then(() => requests.stopAdmission());
+        return {
+            turnSequence: turn.sequence,
+            drive: selected,
+            requests,
+            cwd,
+            options,
+            releaseDriveSignal: () => input.supervisor.signal.removeEventListener("abort", cancelDrive),
+            ...(session === undefined ? {} : { resume: session }),
+        };
+    }
+    catch (error) {
+        return await failedTurnSetup(input, turn.sequence, requests, cancelDrive, error);
+    }
+}
+async function retireProviderCustody(input, turnSequence, drive) {
+    const dispose = async (operation) => await Promise.race([
+        operation().then(() => ({ kind: "retired" }), (error) => ({ kind: "held", error })),
+        abortableDelay(CONTROL_RESPONSE_MS).then(() => ({
+            kind: "held",
+            error: new Error(`provider custody remained live after ${CONTROL_RESPONSE_MS}ms`),
+        })),
+    ]);
+    let outcome = await dispose(drive.abort);
+    if (outcome.kind === "retired")
+        return outcome;
+    outcome = await dispose(drive.forceDispose);
+    if (outcome.kind === "retired")
+        return outcome;
+    if (await heartExists(input.paths)) {
+        const diagnostic = outcome.error instanceof Error ? outcome.error.message : String(outcome.error);
+        const at = input.now();
+        try {
+            await input.supervisor.recordHung(diagnostic, at);
+            await appendActivity(input.paths, {
+                turnSequence,
+                event: encodeAgentEvent({ type: "note", text: `Provider custody was not retired: ${diagnostic}` }),
+                at,
+            });
+        }
+        catch { /* Undisposed provider custody still owns the leash. */ }
+    }
+    await breakBody(input.paths, { sequence: input.bodySequence, end: "broke-off", at: input.now() });
+    return { kind: "hung" };
+}
+function pumpReceipts(writers) {
+    const { input, turnSequence, drive, writeWitness, mayWrite } = writers;
+    return (async () => {
+        if (drive.receipts === undefined)
+            return;
+        for await (const receipt of drive.receipts) {
+            if (!mayWrite())
+                return;
+            await writeWitness(async () => {
+                if (!mayWrite())
+                    return;
+                await recordTellReceipt(input.paths, receipt.evidence === "exact"
+                    ? { ...receipt, receivedAt: input.now() }
+                    : { ...receipt, turnSequence, receivedAt: input.now() });
+            });
+        }
+    })();
+}
+function observeReceiptFailure(receiptPump) {
+    return receiptPump.then(() => new Promise(() => { }), (error) => Promise.reject(error));
+}
+async function submitPendingLiveTells(writers, pending, attempted, tellLive) {
+    const { input, turnSequence, drive, writeWitness, mayWrite } = writers;
+    for (const tell of pending) {
+        if (attempted.has(tell.id))
+            continue;
+        attempted.add(tell.id);
+        const outcome = await writeWitness(async () => {
+            const submission = await tellLive({ id: tell.id, text: tell.body });
+            if (!mayWrite() || submission.kind === "turn-ended")
+                return "turn-ended";
+            await recordTellDeliveries(input.paths, [{
+                    tellId: tell.id,
+                    route: "live",
+                    turnSequence,
+                    fence: submission.fence,
+                    receipt: drive.receipts === undefined ? "unavailable" : "required",
+                    deliveredAt: input.now(),
+                }]);
+            return "accepted";
+        });
+        if (outcome === "turn-ended")
+            return outcome;
+    }
+    return "live";
+}
+async function stopActiveDrive(input, active) {
+    try {
+        const retirement = await retireProviderCustody(input, active.turnSequence, active.drive);
+        await active.requests.close();
+        return retirement;
+    }
+    finally {
+        active.releaseDriveSignal();
+    }
+}
+function hasUnattemptedTell(liveTells, tellPump, pending, attempted) {
+    return liveTells && tellPump === null && pending.some((tell) => !attempted.has(tell.id));
+}
+async function settleCompletion(result, session, active) {
+    try {
+        await active.requests.close();
+        return result.kind === "answered" ? { ...result, ...(session === undefined ? {} : { session }) } : result;
+    }
+    finally {
+        active.releaseDriveSignal();
+    }
+}
+async function consumeTurnDrive(input, active) {
+    const { turnSequence, drive, requests, resume } = active;
+    let heart = input.supervisor.current();
+    let turnSession = resume;
+    const attempted = new Set(input.launchTells.map((tell) => tell.id));
+    const writeWitness = serializeEffects();
+    let writesOpen = true;
+    const mayWrite = () => writesOpen && !input.supervisor.signal.aborted;
+    const writers = { input, turnSequence, drive, writeWitness, mayWrite };
+    const receiptFailure = observeReceiptFailure(pumpReceipts(writers));
+    const iterator = drive.events[Symbol.asyncIterator]();
+    let pending = iterator.next();
+    let liveTells = true;
+    let tellPump = null;
+    let tellObservation = null;
+    try {
+        for (;;) {
+            if (input.supervisor.signal.aborted) {
+                writesOpen = false;
+                const retirement = await stopActiveDrive(input, active);
+                return retirement.kind === "hung" ? retirement : { kind: "stopped" };
+            }
+            if (hasUnattemptedTell(liveTells, tellPump, heart.pending, attempted)) {
+                if (drive.tell === undefined) {
+                    writesOpen = false;
+                    const retirement = await stopActiveDrive(input, active);
+                    return retirement.kind === "hung" ? retirement : { kind: "handoff" };
+                }
+                tellPump = submitPendingLiveTells(writers, heart.pending, attempted, drive.tell);
+                tellObservation = tellPump.then((result) => ({ kind: "tell", result }));
+            }
+            const next = await Promise.race([
+                pending.then((event) => ({ kind: "event", event })),
+                input.supervisor.next(heart).then((observation) => ({ kind: "heart", observation })),
+                ...(tellObservation === null ? [] : [tellObservation]),
+                receiptFailure,
+                requests.failure,
+            ]);
+            if (next.kind === "heart") {
+                heart = next.observation;
+                continue;
+            }
+            if (next.kind === "tell") {
+                tellPump = null;
+                tellObservation = null;
+                liveTells = next.result === "live";
+                continue;
+            }
+            if (next.event.done)
+                break;
+            await writeProviderEvent(input, active, next.event.value);
+            if (next.event.value.type === "session")
+                turnSession = next.event.value.coordinate;
+            pending = iterator.next();
+        }
+        const result = await drive.completion;
+        if (tellPump !== null)
+            await tellPump;
+        await writeWitness.drain();
+        writesOpen = false;
+        return await settleCompletion(result, turnSession, active);
+    }
+    catch (error) {
+        writesOpen = false;
+        if (input.supervisor.signal.aborted) {
+            const retirement = await stopActiveDrive(input, active);
+            return retirement.kind === "hung" ? retirement : { kind: "stopped" };
+        }
+        const retirement = await retireProviderCustody(input, turnSequence, drive);
+        try {
+            await requests.close();
+        }
+        catch { /* Preserve the first pump failure. */ }
+        active.releaseDriveSignal();
+        if (retirement.kind === "hung")
+            return retirement;
+        return { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error) };
+    }
+}
+export async function driveTurn(input) {
+    let active;
+    try {
+        const started = await startTurnDrive(input);
+        if ("kind" in started)
+            return started;
+        active = started;
+    }
+    catch (error) {
+        if (!await heartExists(input.paths)) {
+            input.supervisor.cancel("heart-gone");
+            return { kind: "stopped" };
+        }
+        throw error;
+    }
+    try {
+        const result = await consumeTurnDrive(input, active);
+        return result.kind === "stopped" || result.kind === "hung" || result.kind === "handoff"
+            ? result
+            : { ...result, turnSequence: active.turnSequence };
+    }
+    catch (error) {
+        if (await heartExists(input.paths)) {
+            try {
+                await active.requests.close();
+            }
+            finally {
+                active.releaseDriveSignal();
+            }
+            return {
+                kind: "failed",
+                diagnostic: error instanceof Error ? error.message : String(error),
+                turnSequence: active.turnSequence,
+            };
+        }
+        input.supervisor.cancel("heart-gone");
+        const retirement = await stopActiveDrive(input, active);
+        return retirement.kind === "hung" ? retirement : { kind: "stopped" };
+    }
+}

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

@@ -1,8 +1,8 @@
 import { type SessionFact, type Soul } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
-import { type ProviderAdapter } from "./provider.js";
+import type { ProviderAdapter } from "./provider.js";
 import { type UpstreamExecutionPort, type RequestChildLaunch } from "./request-serve.js";
-export declare const CONTROL_RESPONSE_MS = 1000;
+export { CONTROL_RESPONSE_MS } from "./body-turn.js";
 export type BodyLaunch = Readonly<{
     paths: AkumaPaths;
     seed?: Omit<Soul, "createdAt">;
@@ -16,8 +16,4 @@ type BodyRuntime = Readonly<{
 }>;
 export declare function driveAkumaBody(launch: BodyLaunch, adapter?: ProviderAdapter, runtime?: BodyRuntime): Promise<void>;
 export declare function spawnAkumaBody(launch: BodyLaunch): Promise<void>;
-export declare function runAkumaBody(upstreamFor: (launch: BodyLaunch, configuration: Readonly<{
-    home?: string;
-    gitPath?: string;
-}>) => UpstreamExecutionPort): Promise<void>;
-export {};
+export declare function runAkumaBody(launch: BodyLaunch, upstream: UpstreamExecutionPort): Promise<void>;