@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/task/store.js

@@ -1,18 +1,37 @@
 import { randomBytes } from "node:crypto";
-import { closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { closeSync, fsyncSync, openSync, renameSync, writeFileSync, } from "node:fs";
+import { lstat, mkdir, readFile, readdir, unlink } from "node:fs/promises";
 import { dirname, relative, resolve, sep } from "node:path";
 import { acquireSqliteTransactionLock, SqliteTransactionLockError } from "../coordination/sqlite-transaction-lock.js";
 import { parseTaskDocument } from "./document.js";
 import { formatTaskId, parseTaskId, taskAuthorityPath } from "./identity.js";
-function tasksDirectory(world) { return resolve(world.root, ".keiyaku", "tasks"); }
-function authorityFiles(directory) {
-    if (!existsSync(directory))
-        return [];
+function syncTaskDirectory(path) {
+    if (process.platform === "win32")
+        return;
+    const directory = openSync(path, "r");
+    try {
+        fsyncSync(directory);
+    }
+    finally {
+        closeSync(directory);
+    }
+}
+function tasksDirectory(world) { return resolve(world, ".keiyaku", "tasks"); }
+async function authorityFiles(directory) {
     const files = [];
-    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    for (const entry of entries) {
         const path = resolve(directory, entry.name);
         if (entry.isDirectory())
-            files.push(...authorityFiles(path));
+            files.push(...await authorityFiles(path));
         else if (entry.isFile() && entry.name.endsWith(".md"))
             files.push(path);
         else
@@ -26,16 +45,18 @@ function coordinateFromPath(tasksDirectory, path) {
         throw new Error(`invalid Task authority path: ${path}`);
     return parseTaskId(`task/${local.slice(0, -3).split(sep).join("/")}`);
 }
-export function readBoard(world) {
+export async function readBoard(world) {
     const directory = tasksDirectory(world);
-    const tasks = new Map(), bytes = new Map();
-    for (const path of authorityFiles(directory)) {
-        const stat = lstatSync(path);
-        if (!stat.isFile() || stat.isSymbolicLink())
+    const tasks = new Map();
+    const bytes = new Map();
+    for (const path of await authorityFiles(directory)) {
+        const stat = await lstat(path);
+        if (!stat.isFile() || stat.isSymbolicLink()) {
             throw new Error(`Task authority is not a regular file: ${path}`);
+        }
         const coordinate = coordinateFromPath(directory, path);
         const id = formatTaskId(coordinate);
-        const source = readFileSync(path);
+        const source = await readFile(path);
         tasks.set(id, parseTaskDocument(source, coordinate));
         bytes.set(id, source);
     }
@@ -44,9 +65,9 @@ export function readBoard(world) {
 function equal(left, right) {
     return left === null || right === null ? left === right : Buffer.from(left).equals(Buffer.from(right));
 }
-function currentBytes(path) {
+async function currentBytes(path) {
     try {
-        return readFileSync(path);
+        return await readFile(path);
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -54,9 +75,9 @@ function currentBytes(path) {
         throw error;
     }
 }
-export function replaceAuthority(input) {
+export async function replaceAuthority(input) {
     const parent = dirname(input.path);
-    mkdirSync(parent, { recursive: true });
+    await mkdir(parent, { recursive: true });
     const temporary = resolve(parent, `.tmp-${randomBytes(8).toString("hex")}`);
     let descriptor;
     try {
@@ -65,34 +86,28 @@ export function replaceAuthority(input) {
         fsyncSync(descriptor);
         closeSync(descriptor);
         descriptor = undefined;
-        if (!equal(currentBytes(input.path), input.expected))
+        if (!equal(await currentBytes(input.path), input.expected))
             return "concurrent-modification";
         renameSync(temporary, input.path);
-        const directoryDescriptor = openSync(parent, "r");
-        try {
-            fsyncSync(directoryDescriptor);
-        }
-        finally {
-            closeSync(directoryDescriptor);
-        }
+        syncTaskDirectory(parent);
         return "replaced";
     }
     finally {
         if (descriptor !== undefined)
             closeSync(descriptor);
         try {
-            unlinkSync(temporary);
+            await unlink(temporary);
         }
         catch { /* renamed or best effort */ }
     }
 }
 function lockPath(world, id) {
     const coordinate = parseTaskId(id);
-    return resolve(world.root, ".keiyaku", "locks", "task", ...coordinate.namespace, `${coordinate.localId}.sqlite`);
+    return resolve(world, ".keiyaku", "locks", "task", ...coordinate.namespace, `${coordinate.localId}.sqlite`);
 }
 export async function withTaskLocks(input, action) {
     const paths = [
-        ...(input.allocation ? [resolve(input.world.root, ".keiyaku", "locks", "task-allocation.sqlite")] : []),
+        ...(input.allocation ? [resolve(input.world, ".keiyaku", "locks", "task-allocation.sqlite")] : []),
         ...[...new Set(input.ids)].sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b))).map((id) => lockPath(input.world, id)),
     ];
     const held = [];

package/build/src/verification/declaration.d.ts

@@ -4,6 +4,7 @@ export type VerificationExecutor = "bash" | "zsh" | "pwsh";
 export type VerificationDeclaration = Readonly<{
     readonly executor: VerificationExecutor;
     readonly script: string;
+    readonly timeoutMs?: number;
 }>;
 export type VerificationDefinition = Readonly<{
     readonly segment: DocumentSegmentKey;

package/build/src/verification/execution.d.ts

@@ -0,0 +1,51 @@
+import type { SnapshotId } from "../core/facts/types.js";
+import { type HookFailure } from "../git/hooks.js";
+import type { MaterializedScratchCandidate, WorktreeLeak } from "../git/scratch.js";
+import type { GitRepository } from "../git/repository.js";
+import type { Settings } from "../settings.js";
+import type { VerificationDeclaration } from "./declaration.js";
+type VerificationVerdict = "satisfied" | "unsatisfied";
+export type VerificationTerminalOutcome = Readonly<{
+    kind: "terminal";
+    verdict: VerificationVerdict;
+    passed: number;
+    total: number;
+    summary?: string;
+}>;
+export type VerificationNonterminalOutcome = Readonly<{
+    kind: "unknown-exit";
+}> | Readonly<{
+    kind: "cancelled";
+}> | Readonly<{
+    kind: "spawn-error";
+    diagnostic: string;
+}>;
+export type VerificationExecutionStop = VerificationNonterminalOutcome | Readonly<{
+    kind: "candidate-unavailable" | "environment-failure";
+    diagnostic: string;
+}> | Readonly<{
+    kind: "environment-failure";
+    command: number;
+    detail: HookFailure;
+}>;
+export type VerificationExecution = Readonly<{
+    outcome: VerificationTerminalOutcome | VerificationExecutionStop;
+    cleanup?: Readonly<{
+        phase: "destroy";
+        command: number;
+        detail: HookFailure;
+    }>;
+    leak?: WorktreeLeak;
+}>;
+export type ExecuteVerificationInput = Readonly<{
+    repository: GitRepository;
+    candidate: SnapshotId;
+    declarations: readonly VerificationDeclaration[];
+    environment: NodeJS.ProcessEnv;
+    materializeScratchCandidate: (repository: GitRepository, candidate: SnapshotId) => Promise<MaterializedScratchCandidate>;
+    projectSettings: (root: string) => Promise<Settings>;
+    signal?: AbortSignal;
+}>;
+/** Execute one disposable Verification attempt over the exact integration snapshot. */
+export declare function executeVerification(input: ExecuteVerificationInput): Promise<VerificationExecution>;
+export {};

package/build/src/verification/execution.js

@@ -0,0 +1,108 @@
+import { runHookCommands, worktreeHooksFrom } from "../git/hooks.js";
+import { runProcess } from "../runtime/proc/run.js";
+const SUMMARY_BYTES = 32 * 1024;
+function argvFor(declaration) {
+    const args = declaration.executor === "pwsh" ? ["-Command", declaration.script] : ["-c", declaration.script];
+    return [declaration.executor, ...args];
+}
+function processDiagnostic(declaration, index, outcome) {
+    if (outcome.code === 0 && outcome.stdout.length === 0 && outcome.stderr.length === 0 && !outcome.truncated) {
+        return null;
+    }
+    return [
+        `[${index + 1} ${declaration.executor} exit ${outcome.code}${outcome.truncated ? " output-truncated" : ""}]`,
+        ...(outcome.stdout.length === 0 ? [] : [`stdout:\n${outcome.stdout}`]),
+        ...(outcome.stderr.length === 0 ? [] : [`stderr:\n${outcome.stderr}`]),
+    ].join("\n");
+}
+function appendSummary(current, diagnostic) {
+    if (diagnostic === null)
+        return current;
+    const combined = Buffer.from(current === undefined ? diagnostic : `${current}\n\n${diagnostic}`);
+    if (combined.length <= SUMMARY_BYTES)
+        return combined.toString("utf8");
+    const marker = Buffer.from("[earlier output truncated]\n");
+    let start = combined.length - (SUMMARY_BYTES - marker.length);
+    while (start < combined.length && (combined[start] & 0xc0) === 0x80)
+        start += 1;
+    return Buffer.concat([marker, combined.subarray(start)]).toString("utf8");
+}
+async function executeDeclarations(input) {
+    let verdict = "satisfied";
+    let passed = 0;
+    const total = input.declarations.length;
+    let summary;
+    for (const [index, declaration] of input.declarations.entries()) {
+        const outcome = await runProcess({
+            argv: argvFor(declaration),
+            cwd: input.cwd,
+            env: input.environment,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+            ...(declaration.timeoutMs === undefined ? {} : { timeoutMs: declaration.timeoutMs }),
+        });
+        if (outcome.kind === "timeout") {
+            verdict = "unsatisfied";
+            summary = appendSummary(summary, `[${index + 1} ${declaration.executor} timeout after ${declaration.timeoutMs}ms]`);
+            continue;
+        }
+        if (outcome.kind === "spawn-error" || outcome.kind === "unknown-exit" || outcome.kind === "cancelled")
+            return outcome;
+        if (outcome.code === 0)
+            passed += 1;
+        else
+            verdict = "unsatisfied";
+        summary = appendSummary(summary, processDiagnostic(declaration, index, outcome));
+    }
+    return { kind: "terminal", verdict, passed, total, ...(summary === undefined ? {} : { summary }) };
+}
+/** Execute one disposable Verification attempt over the exact integration snapshot. */
+export async function executeVerification(input) {
+    let scratch;
+    try {
+        scratch = await input.materializeScratchCandidate(input.repository, input.candidate);
+    }
+    catch (error) {
+        return { outcome: { kind: "candidate-unavailable", diagnostic: error instanceof Error ? error.message : String(error) } };
+    }
+    let outcome;
+    let cleanup;
+    let leak = null;
+    let destroy;
+    try {
+        try {
+            const hooks = worktreeHooksFrom({ settings: await input.projectSettings(scratch.cwd) });
+            destroy = hooks.destroy;
+            const readiness = await runHookCommands(scratch.cwd, hooks.create, input.signal);
+            outcome = readiness.kind === "cancelled"
+                ? { kind: "cancelled" }
+                : readiness.kind === "failed"
+                    ? { kind: "environment-failure", command: readiness.command, detail: readiness.failure }
+                    : await executeDeclarations({
+                        declarations: input.declarations,
+                        cwd: scratch.cwd,
+                        environment: input.environment,
+                        ...(input.signal === undefined ? {} : { signal: input.signal }),
+                    });
+        }
+        catch (error) {
+            outcome = { kind: "environment-failure", diagnostic: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    finally {
+        if (destroy !== undefined) {
+            const result = await runHookCommands(scratch.cwd, destroy);
+            if (result.kind === "cancelled")
+                throw new Error("scratch destroy cancelled without a signal");
+            if (result.kind === "failed")
+                cleanup = { phase: "destroy", command: result.command, detail: result.failure };
+        }
+        leak = await scratch.dispose();
+    }
+    if (outcome === undefined)
+        throw new Error("Verification ended without an outcome");
+    return {
+        outcome,
+        ...(cleanup === undefined ? {} : { cleanup }),
+        ...(leak === null ? {} : { leak }),
+    };
+}

package/build/src/workspace-place.d.ts

@@ -0,0 +1,41 @@
+import { type ContractId } from "./core/facts/types.js";
+import type { GitRepository } from "./git/repository.js";
+export declare const CONTRACT_PLACES: readonly string[];
+export type Place = string & {
+    readonly [placeBrand]: "Place";
+};
+declare const placeBrand: unique symbol;
+export type PlaceAppointment = Readonly<{
+    place: Place;
+    contract: ContractId;
+}>;
+export type PlaceRegister = Readonly<{
+    appointments: readonly PlaceAppointment[];
+    byPlace: ReadonlyMap<Place, PlaceAppointment>;
+    byContract: ReadonlyMap<ContractId, PlaceAppointment>;
+}>;
+export type ManagedWorktreeAppointment = Readonly<{
+    kind: "appointed";
+    place: Place;
+    path: string;
+}> | Readonly<{
+    kind: "unappointed";
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+}>;
+export declare function placeRegisterPath(repository: GitRepository): string;
+export declare function place(value: string): Place;
+export declare function nextPlace(current?: Place): Place;
+export declare function firstFreePlace(register: PlaceRegister): Place;
+export declare function canonicalPlaceRegister(register: PlaceRegister): string;
+export declare function decodePlaceRegister(path: string, bytes: string): PlaceRegister;
+export declare function emptyPlaceRegister(): PlaceRegister;
+export declare function readPlaceRegister(repository: GitRepository): Promise<PlaceRegister>;
+export declare function appointmentFor(register: PlaceRegister, contract: ContractId): PlaceAppointment | undefined;
+export declare function appointManagedWorktrees(repository: GitRepository, contracts: readonly ContractId[]): Promise<PlaceRegister>;
+export declare function appointManagedWorktree(repository: GitRepository, contract: ContractId): Promise<PlaceAppointment>;
+export declare function releaseManagedWorktrees(repository: GitRepository, contracts: readonly ContractId[]): Promise<void>;
+export declare function releaseManagedWorktree(repository: GitRepository, contract: ContractId): Promise<void>;
+export declare function readManagedWorktreeAppointment(repository: GitRepository, contract: ContractId, register?: PlaceRegister): Promise<ManagedWorktreeAppointment>;
+export {};