@astrosheep/keiyaku 4.0.4 → 4.0.5

package/build/src/akuma/providers/acp/core.js

@@ -2,7 +2,7 @@ import * as acp from "@agentclientprotocol/sdk";
 import { Readable, Writable } from "node:stream";
 import { spawnStdioProcess } from "../../../runtime/proc/stdio.js";
 import { abortable } from "../../abort.js";
-import { AgentEventChannel, } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { EMPTY_ACP_EVENT_STATE, flushAcpEvents, mapAcpUpdate, } from "./events.js";
 function diagnostic(error) {
     if (!(error instanceof Error))
@@ -130,7 +130,11 @@ export async function startAcpSession(launch, input, dependencies = {}) {
     const child = (dependencies.spawnProcess ?? spawnStdioProcess)({
         argv: launch.argv,
         cwd: input.cwd,
-        env: { ...globalThis.process.env, ...launch.env },
+        env: {
+            ...globalThis.process.env,
+            ...launch.env,
+            ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
+        },
     });
     let sessionId;
     let turn;

package/build/src/akuma/providers/acp/index.js

@@ -86,7 +86,6 @@ export function createAcpProvider(execution, dependencies = {}) {
         return (await startAcpSession(launch, input, dependencies)).session;
     };
     return {
-        confinement: () => ({ kind: "unconfined" }),
         admitOptions: (options) => optionAdmission(options, config),
         start: async (input) => await drive(input),
         resume: async (input) => await drive(input),

package/build/src/akuma/providers/claude/index.d.ts

@@ -21,10 +21,6 @@ export type ClaudeSdk = Readonly<{
 }>;
 export declare function createClaudeProvider(load: () => Promise<ClaudeSdk>, execution?: ClaudeExecution): ProviderAdapter;
 export declare const claudeProvider: Readonly<{
-    confinement(input: Readonly<{
-        cwd: string;
-        options: ProviderOptions;
-    }>): import("../../index.js").Confinement;
     admitOptions(options: ProviderOptions): import("../../provider.js").ProviderOptionAdmission;
     fork?(input: Readonly<{
         session: ResumeCoordinate;

package/build/src/akuma/providers/claude/index.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { abortable } from "../../abort.js";
-import { AgentEventChannel, } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { emitClaudeMessage, } from "./events.js";
 import { claudeUserMessage, createClaudeInput, isClaudeTurnEnded } from "./input.js";
 export { CLAUDE_MESSAGE_DISPOSITIONS, CLAUDE_SYSTEM_DISPOSITIONS } from "./events.js";
@@ -61,8 +61,13 @@ function claudeQueryOptions(input, execution, abortController) {
     return {
         cwd: input.cwd,
         abortController,
+        ...(input.requests === undefined ? {} : { additionalDirectories: [input.requests.dir] }),
         ...(execution.executable === undefined ? {} : { pathToClaudeCodeExecutable: execution.executable }),
-        ...(execution.env === undefined ? {} : { env: { ...process.env, ...execution.env } }),
+        ...((execution.env === undefined && input.requests === undefined) ? {} : { env: {
+                ...process.env,
+                ...execution.env,
+                ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
+            } }),
         permissionMode: mode,
         ...(mode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
         settingSources: ["user", "project", "local"],
@@ -269,7 +274,6 @@ async function driveClaude(load, execution, drive) {
 }
 export function createClaudeProvider(load, execution = {}) {
     return {
-        confinement: () => ({ kind: "unconfined" }),
         admitOptions: admitClaudeOptions,
         fork: (input) => forkClaude(load, execution, input),
         start: (input) => driveClaude(load, execution, input),

package/build/src/akuma/providers/codex-app-server/index.d.ts

@@ -1,29 +1,4 @@
-import { type Session, type ProviderAdapter } from "../../provider.js";
-import type { ProviderExecution, ProviderOptions } from "../../provider-recipe.js";
+import { type ProviderAdapter } from "../../provider.js";
+import type { ProviderExecution } from "../../provider-recipe.js";
 export { CODEX_ITEM_DISPOSITIONS, CODEX_NOTIFICATION_DISPOSITIONS } from "./events.js";
 export declare function createCodexAppServerProvider(input?: string | ProviderExecution): ProviderAdapter;
-export declare const codexAppServerProvider: Readonly<{
-    confinement(input: Readonly<{
-        cwd: string;
-        options: ProviderOptions;
-    }>): import("../../index.js").Confinement;
-    admitOptions(options: ProviderOptions): import("../../provider.js").ProviderOptionAdmission;
-    fork?(input: Readonly<{
-        session: import("../../coordinate.js").ResumeCoordinate;
-        at: string;
-        cwd: string;
-    }>): Promise<Readonly<{
-        session: import("../../coordinate.js").ResumeCoordinate;
-    }>>;
-    start(input: import("../../provider.js").DriveInput & Readonly<{
-        session: Readonly<{
-            kind: "fresh";
-        }>;
-    }>): Promise<Session>;
-    resume?(input: import("../../provider.js").DriveInput & Readonly<{
-        session: Readonly<{
-            kind: "resume";
-            coordinate: import("../../coordinate.js").ResumeCoordinate;
-        }>;
-    }>): Promise<Session>;
-}>;

package/build/src/akuma/providers/codex-app-server/index.js

@@ -190,7 +190,6 @@ export function createCodexAppServerProvider(input = "codex") {
         ? { name: "codex-app-server", kind: "codex-app-server", executable: input }
         : input;
     return {
-        confinement: ({ cwd }) => ({ kind: "declared", writableRoots: [cwd] }),
         admitOptions(options) {
             return {
                 kind: "admitted",
@@ -203,4 +202,3 @@ export function createCodexAppServerProvider(input = "codex") {
         resume: (input) => startCodex(execution, input),
     };
 }
-export const codexAppServerProvider = createCodexAppServerProvider();

package/build/src/akuma/providers/grok-build/index.js

@@ -132,7 +132,6 @@ export function createGrokBuildProvider(execution, dependencies = {}) {
         }));
     };
     return {
-        confinement: () => ({ kind: "unconfined" }),
         admitOptions: optionAdmission,
         start: async (input) => await drive(input),
         resume: async (input) => await drive(input),

package/build/src/akuma/providers/opencode-sdk/index.d.ts

@@ -1,33 +1,7 @@
-import { type ProviderAdapter, type Session } from "../../provider.js";
-import type { ResumeCoordinate } from "../../heart/index.js";
-import type { ProviderExecution, ProviderOptions } from "../../provider-recipe.js";
+import { type ProviderAdapter } from "../../provider.js";
+import type { ProviderExecution } from "../../provider-recipe.js";
 import { type OpencodeSdkLoader } from "./session.js";
 export type OpencodeProviderTestOptions = Readonly<{
     loader?: OpencodeSdkLoader;
 }>;
 export declare function createOpencodeProvider(input?: ProviderExecution | OpencodeProviderTestOptions): ProviderAdapter;
-export declare const opencodeProvider: Readonly<{
-    confinement(input: Readonly<{
-        cwd: string;
-        options: ProviderOptions;
-    }>): import("../../heart/facts.js").Confinement;
-    admitOptions(options: ProviderOptions): import("../../provider.js").ProviderOptionAdmission;
-    fork?(input: Readonly<{
-        session: ResumeCoordinate;
-        at: string;
-        cwd: string;
-    }>): Promise<Readonly<{
-        session: ResumeCoordinate;
-    }>>;
-    start(input: import("../../provider.js").DriveInput & Readonly<{
-        session: Readonly<{
-            kind: "fresh";
-        }>;
-    }>): Promise<Session>;
-    resume?(input: import("../../provider.js").DriveInput & Readonly<{
-        session: Readonly<{
-            kind: "resume";
-            coordinate: ResumeCoordinate;
-        }>;
-    }>): Promise<Session>;
-}>;

package/build/src/akuma/providers/opencode-sdk/index.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { abortable } from "../../abort.js";
-import { AgentEventChannel } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { createEventState, mapEvent } from "./events.js";
 import { coordinate, loadOpencode, OPENCODE_SDK_PROVIDER, parseModel } from "./session.js";
 function object(value) {
@@ -205,7 +205,13 @@ async function drive(execution, input, loader) {
     const abortSetup = () => abortController.abort(signal.reason);
     signal.addEventListener("abort", abortSetup, { once: true });
     signal.throwIfAborted();
-    const runtime = await abortable(loadOpencode(execution, input.cwd, abortController.signal, loader), abortController.signal, async (late) => await late.close());
+    const runtime = await abortable(loadOpencode({
+        ...execution,
+        env: {
+            ...execution.env,
+            ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
+        },
+    }, input.cwd, abortController.signal, loader), abortController.signal, async (late) => await late.close());
     let closing;
     let iterator;
     const closeOnce = () => {
@@ -263,7 +269,6 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
     const execution = "kind" in input ? input : { name: OPENCODE_SDK_PROVIDER, kind: "opencode-sdk" };
     const loader = "loader" in input ? input.loader : undefined;
     return {
-        confinement: ({ cwd }) => ({ kind: "declared", writableRoots: [cwd] }),
         admitOptions(options) {
             try {
                 admit(options);
@@ -305,4 +310,3 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
         },
     };
 }
-export const opencodeProvider = createOpencodeProvider();

package/build/src/akuma/providers/opencode-sdk/session.d.ts

@@ -3,7 +3,7 @@ import type { ResumeCoordinate } from "../../heart/index.js";
 import type { ProviderExecution } from "../../provider-recipe.js";
 export type OpencodeSdkSession = Pick<OpencodeClient["session"], "create" | "get" | "fork" | "abort" | "promptAsync" | "messages">;
 export type OpencodeSdkEvent = Pick<OpencodeClient["event"], "subscribe">;
-export type OpencodeSdkLoader = (cwd: string) => Promise<Readonly<{
+export type OpencodeSdkLoader = (cwd: string, execution: ProviderExecution) => Promise<Readonly<{
     client: {
         session: OpencodeSdkSession;
         event: OpencodeSdkEvent;

package/build/src/akuma/providers/opencode-sdk/session.js

@@ -40,7 +40,7 @@ async function availablePort() {
 }
 export async function loadOpencode(execution, cwd, signal, loader) {
     if (loader) {
-        const loaded = await loader(cwd);
+        const loaded = await loader(cwd, execution);
         return { client: loaded.client, close: async () => { await loaded.close?.(); } };
     }
     const port = await availablePort();

package/build/src/akuma/providers/pi/index.js

@@ -1,9 +1,9 @@
-import { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { createAgentSession, createBashToolDefinition, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { abortable } from "../../abort.js";
-import { AgentEventChannel } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { piTerminalFailure, translatePiEvent } from "./events.js";
 const PI_THINKING_LEVELS = new Set(["minimal", "low", "medium", "high", "xhigh", "max"]);
-const MODEL_PATTERN = /^[^/\s]+\/[^/\s]+$/u;
+const MODEL_PATTERN = /^[^/\s]+\/[^\s]+$/u;
 function diagnostic(error) { return error instanceof Error ? error.message : String(error); }
 function admitPiOptions(options) {
     if (options.network !== undefined)
@@ -48,6 +48,14 @@ async function piCreateOptions(sdk, input) {
         ...(resourceLoader === undefined ? {} : { resourceLoader }),
         ...(input.options.effort === undefined ? {} : { thinkingLevel: input.options.effort }),
         ...(input.options.readonly === undefined ? {} : { tools: ["read", "grep", "find", "ls"] }),
+        ...(input.requests === undefined || input.options.readonly === true
+            ? {}
+            : { customTools: [createBashToolDefinition(input.cwd, {
+                        spawnHook: (context) => ({
+                            ...context,
+                            env: { ...context.env, [AKUMA_REQUESTS_ENV]: input.requests.dir },
+                        }),
+                    })] }),
     };
 }
 async function createPiSession(sdk, input, signal) {
@@ -176,7 +184,6 @@ export function createPiProvider(execution = { name: "pi", kind: "pi" }, load =
         return drivePi(await abortable(load(), signal), input, signal);
     };
     return {
-        confinement: ({ cwd }) => ({ kind: "declared", writableRoots: [cwd] }),
         admitOptions: admitPiOptions,
         start: drive,
         resume: async (input) => {

package/build/src/akuma/request-serve.d.ts

@@ -0,0 +1,87 @@
+import { type KillEvidence, type Soul } from "./heart/index.js";
+import { type AkuId, type AkumaPaths } from "./identity.js";
+import { type TaskMutationRequest } from "../task/mutation.js";
+export type RequestChildLaunch = Readonly<{
+    paths: AkumaPaths;
+    seed: Omit<Soul, "createdAt">;
+    initialBody: string;
+}>;
+type UpstreamCall = Readonly<{
+    signal: AbortSignal;
+}>;
+type RequesterCall = UpstreamCall & Readonly<{
+    requester: AkuId;
+}>;
+type ContractCall = RequesterCall & Readonly<{
+    repoRoot: string;
+    contractId: string;
+}>;
+export type UpstreamExecutionPort = Readonly<{
+    wait(input: UpstreamCall & Readonly<{
+        targets: readonly AkuId[];
+        completion: "any" | "all";
+        timeoutMs?: number;
+    }>): Promise<unknown>;
+    tell(input: UpstreamCall & Readonly<{
+        target: AkuId;
+        body: string;
+        tellId: string;
+        recordedAt: string;
+    }>): Promise<unknown>;
+    kill(input: Readonly<{
+        targets: readonly AkuId[];
+        signal: AbortSignal;
+    }>): Promise<Readonly<{
+        result: unknown;
+        service: readonly Readonly<{
+            id: AkuId;
+            evidence: KillEvidence;
+        }>[];
+    }>>;
+    deliver(input: ContractCall & Readonly<{
+        message?: string;
+        includeDirty: boolean;
+    }>): Promise<Readonly<{
+        result: unknown;
+        deliveryFactId?: string;
+    }>>;
+    review(input: ContractCall & Readonly<{
+        verdict: "satisfied" | "unsatisfied";
+        summary?: string;
+    }>): Promise<Readonly<{
+        result: unknown;
+        reviewFactId?: string;
+    }>>;
+    task(input: RequesterCall & Readonly<{
+        world: string;
+        request: TaskMutationRequest;
+    }>): Promise<unknown>;
+}>;
+type PumpInput = Readonly<{
+    paths: AkumaPaths;
+    parent: Soul;
+    bodySequence: number;
+    now(): string;
+    spawn(launch: RequestChildLaunch): Promise<void>;
+    upstream?: UpstreamExecutionPort;
+    signal: AbortSignal;
+}>;
+export declare class BodyRequestPump {
+    private readonly input;
+    readonly directory: string;
+    readonly failure: Promise<never>;
+    private readonly closeSignal;
+    private readonly executionSignal;
+    private readonly handled;
+    private readonly running;
+    private readonly cancelBody;
+    private admissionClosed;
+    private constructor();
+    static open(input: PumpInput): 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 {};