@shivaedev/work-fleet 0.0.0 → 0.1.1

package/src/host/githubChecks.ts

@@ -0,0 +1,53 @@
+import { Effect, Schema } from "effect";
+import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import { withFailureContext } from "#engine/failureContext.ts";
+import type { FleetError } from "#errors.ts";
+import { CheckPages, githubCheckState, StatusPages } from "#host/githubCheckState.ts";
+import { githubRead } from "#host/githubRead.ts";
+import { githubRequiredChecks } from "#host/githubRequiredChecks.ts";
+import type { WorkResult } from "#policy.ts";
+
+function failure(message: string) {
+	return new ServiceUnavailable({ message });
+}
+
+export function makeGithubChecks<R>(read: (endpoint: string) => Effect.Effect<string, FleetError, R>, branch = "main") {
+	return Effect.fn("Fleet.githubChecks")(function* (result: WorkResult) {
+		if (result.kind !== "change") {
+			return yield* failure("GitHub checks need an adopted pull request");
+		}
+		const match = /^https:\/\/github\.com\/(?<owner>[A-Za-z0-9-]+)\/(?<repository>[A-Za-z0-9_.-]+)\/pull\/[1-9][0-9]*$/u.exec(result.pr);
+		const owner = match?.groups?.owner;
+		const repository = match?.groups?.repository;
+		if (owner === undefined || repository === undefined || [".", ".."].includes(repository) || /^[0-9a-f]{40}$/u.exec(result.head) === null) {
+			return yield* withFailureContext(
+				new ServiceUnavailable({
+					message: "GitHub checks need a GitHub pull request URL and an exact commit SHA",
+				}),
+				{ code: "checks-result-invalid" },
+			);
+		}
+		const commit = `repos/${owner}/${repository}/commits/${result.head}`;
+		const checks = yield* read(`${commit}/check-runs?per_page=100&filter=latest`).pipe(
+			Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(CheckPages))),
+			Effect.mapError(() => failure("GitHub check runs are unavailable or invalid")),
+		);
+		const statuses = yield* read(`${commit}/status?per_page=100`).pipe(
+			Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(StatusPages))),
+			Effect.mapError(() => failure("GitHub commit statuses are unavailable or invalid")),
+		);
+		if (
+			statuses.length === 0
+			|| checks.some((page) => page.checkRuns.some((check) => check.headSha !== result.head))
+			|| statuses.some((page) => page.sha !== result.head)
+		) {
+			return yield* failure("GitHub checks returned evidence for a different commit SHA");
+		}
+		const required = yield* githubRequiredChecks(read, `${owner}/${repository}`, branch);
+		return githubCheckState(result.head, result.pr, checks, statuses, required);
+	});
+}
+
+export function githubChecks(result: WorkResult, branch = "main") {
+	return makeGithubChecks((endpoint) => githubRead(["api", "--method", "GET", "--paginate", "--slurp", endpoint]), branch)(result);
+}

package/src/host/githubDelivery.ts

@@ -0,0 +1,65 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Effect, Schema } from "effect";
+import { BadRequest, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import { conflictingPr, movedPrHead } from "#engine/deliveryFailure.ts";
+import { withFailureContext } from "#engine/failureContext.ts";
+import type { FleetError } from "#errors.ts";
+import { githubRead } from "#host/githubRead.ts";
+import type { ChangeResult } from "#policy.ts";
+
+const PullRequest = Schema.Struct({
+	baseRefOid: Schema.optional(Schema.NonEmptyString),
+	headRefOid: Schema.NonEmptyString,
+	mergeable: Schema.optional(Schema.Literals(["MERGEABLE", "CONFLICTING", "UNKNOWN"])),
+	mergeCommit: Schema.NullOr(Schema.Struct({ oid: Schema.NonEmptyString })),
+	mergedAt: Schema.NullOr(Schema.NonEmptyString),
+	state: Schema.Literals(["OPEN", "CLOSED", "MERGED"]),
+	url: Schema.NonEmptyString,
+});
+
+function failure(message: string, reason: "integration" | "invalid" = "invalid") {
+	return reason === "integration" ? new ServiceUnavailable({ message }) : new BadRequest({ message });
+}
+
+function readPullRequest(cwd: string, pr: string) {
+	return githubRead(["pr", "view", pr, "--json", "url,state,headRefOid,mergedAt,mergeCommit,mergeable,baseRefOid"], cwd).pipe(
+		Effect.provide(NodeServices.layer),
+		Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))),
+		Effect.mapError(() => failure("PR delivery observation failed; check GitHub CLI access and response", "integration")),
+	);
+}
+
+export function githubDelivery(cwd: string, read: (cwd: string, pr: string) => Effect.Effect<unknown, FleetError> = readPullRequest) {
+	return Effect.fn("FleetHost.githubDelivery")(function* (result: typeof ChangeResult.Type) {
+		if (result.pr.match(/^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/[1-9]\d*$/u) === null) {
+			return yield* withFailureContext(new BadRequest({ message: "Delivery requires the adopted GitHub PR URL" }), { code: "delivery-pr-required" });
+		}
+		const pr = yield* Schema.decodeUnknownEffect(PullRequest)(yield* read(cwd, result.pr)).pipe(
+			Effect.mapError(() => failure("PR delivery observation returned an unknown shape", "integration")),
+		);
+		yield* validateDelivery(pr, result);
+		if (pr.state === "MERGED" && pr.mergedAt !== null && pr.mergeCommit !== null) {
+			return { head: pr.headRefOid, revision: pr.mergeCommit.oid, url: pr.url };
+		}
+		if (pr.mergeable === "CONFLICTING" && pr.baseRefOid !== undefined) {
+			return yield* conflictingPr(pr.baseRefOid);
+		}
+		return undefined;
+	});
+}
+
+const validateDelivery = Effect.fn("FleetHost.validateDelivery")(function* (pr: typeof PullRequest.Type, result: typeof ChangeResult.Type) {
+	if (pr.url !== result.pr) {
+		return yield* failure("Delivery observation differs from the adopted PR");
+	}
+	if (pr.state === "CLOSED" && pr.mergedAt === null && pr.mergeCommit === null) {
+		return yield* failure("PR was closed without merging; inspect the closed PR before retrying or releasing this work");
+	}
+	const merged = pr.state === "MERGED" && pr.mergedAt !== null && pr.mergeCommit !== null;
+	if (!merged && (pr.state !== "OPEN" || pr.mergedAt !== null || pr.mergeCommit !== null)) {
+		return yield* failure("PR delivery evidence is inconsistent; inspect the adopted PR");
+	}
+	if (!merged && pr.headRefOid !== result.head) {
+		return yield* movedPrHead(pr.headRefOid);
+	}
+});

package/src/host/githubRead.ts

@@ -0,0 +1,20 @@
+import { Effect, Stream } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+
+export const githubRead = Effect.fn("Fleet.githubRead")(function* (args: readonly string[], cwd?: string) {
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	return yield* Effect.scoped(
+		Effect.gen(function* () {
+			const process = yield* spawner.spawn(ChildProcess.make("gh", args, cwd === undefined ? {} : { cwd }));
+			const output = yield* process.stdout.pipe(Stream.decodeText, Stream.mkString);
+			if ((yield* process.exitCode) !== 0) {
+				return yield* new ServiceUnavailable({ message: "GitHub request failed" });
+			}
+			return output;
+		}),
+	).pipe(
+		Effect.timeout("60 seconds"),
+		Effect.mapError(() => new ServiceUnavailable({ message: "GitHub evidence could not be read; check gh authentication and repository access" })),
+	);
+});

package/src/host/githubRequiredChecks.ts

@@ -0,0 +1,19 @@
+import { Effect, Schema } from "effect";
+import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { FleetError } from "#errors.ts";
+
+const RulePages = Schema.Array(Schema.Array(Schema.Struct({ parameters: Schema.optional(Schema.Unknown), type: Schema.String })));
+const RequiredParameters = Schema.Struct({ requiredStatusChecks: Schema.Array(Schema.Struct({ context: Schema.String })) }).pipe(
+	Schema.encodeKeys({ requiredStatusChecks: "required_status_checks" }),
+);
+
+export function githubRequiredChecks<R>(read: (endpoint: string) => Effect.Effect<string, FleetError, R>, repository: string, branch: string) {
+	return Effect.gen(function* () {
+		const pages = yield* read(`repos/${repository}/rules/branches/${encodeURIComponent(branch)}`).pipe(
+			Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(RulePages))),
+		);
+		const rules = pages.flat().filter((rule) => rule.type === "required_status_checks");
+		const parameters = yield* Effect.forEach(rules, (rule) => Schema.decodeUnknownEffect(RequiredParameters)(rule.parameters));
+		return [...new Set(parameters.flatMap((rule) => rule.requiredStatusChecks.map((check) => check.context)))];
+	}).pipe(Effect.mapError(() => new ServiceUnavailable({ message: "GitHub required status checks are unavailable or invalid" })));
+}

package/src/host/githubResult.ts

@@ -0,0 +1,76 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Effect } from "effect";
+import { BadRequest, Conflict, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import { withFailureContext } from "#engine/failureContext.ts";
+import type { FleetError } from "#errors.ts";
+import type { FleetHost } from "#host/config.ts";
+import { FilePages, type GithubRead, githubJson, PullRequest, Repository } from "#host/github.ts";
+import { githubRead } from "#host/githubRead.ts";
+import type { MainSource } from "#host/mainSource.ts";
+import { resultReport } from "#host/resultReport.ts";
+import type { BoardWork, WorkResult } from "#policy.ts";
+import type { SessionObservation } from "#session/schema.ts";
+
+export function githubResult(
+	host: FleetHost,
+	main: MainSource["Service"],
+	read: GithubRead = (args) => githubRead(args, main.repositoryRoot).pipe(Effect.provide(NodeServices.layer)),
+) {
+	return Effect.fn("FleetHost.githubResult")(function* (_work: BoardWork, observation: SessionObservation): Effect.fn.Return<WorkResult, FleetError> {
+		if (observation.execution !== "completed") {
+			return yield* new BadRequest({ message: "Result adoption requires completed worker execution" });
+		}
+		const report = yield* resultReport(observation.output);
+		if (report.pr.kind === "none") {
+			return { evidence: [observation.output], head: report.head, kind: "no-change" };
+		}
+		return yield* adoptPullRequest(host, read, report.head, report.pr.url);
+	});
+}
+
+const adoptPullRequest = Effect.fn("FleetHost.adoptPullRequest")(function* (host: FleetHost, read: GithubRead, head: string, prUrl: string) {
+	const repository = yield* githubJson(Repository, read, ["repo", "view", "--json", "nameWithOwner"]);
+	const url = new URL(prUrl);
+	const parts = url.pathname.split("/");
+	const owner = parts[1];
+	const name = parts[2];
+	const number = Number(parts[4]);
+	if (!Number.isSafeInteger(number) || `${owner}/${name}`.toLowerCase() !== repository.nameWithOwner.toLowerCase()) {
+		return yield* withFailureContext(new BadRequest({ message: "Reported PR must belong to the host repository" }), { code: "foreign-pr" });
+	}
+	const endpoint = `repos/${repository.nameWithOwner}/pulls/${number}`;
+	const before = yield* githubJson(PullRequest, read, ["api", endpoint]);
+	yield* validatePullRequest(before, head, number, prUrl, host.repository.branch);
+	const files = (yield* githubJson(FilePages, read, ["api", `${endpoint}/files?per_page=100`, "--paginate", "--slurp"])).flat();
+	const after = yield* githubJson(PullRequest, read, ["api", endpoint]);
+	yield* validatePullRequest(after, head, number, prUrl, host.repository.branch);
+	if (before.changedFiles !== after.changedFiles) {
+		return yield* new Conflict({ message: "PR changed paths moved during observation" });
+	}
+	if (files.length !== after.changedFiles || new Set(files.map((file) => file.filename)).size !== files.length) {
+		return yield* new ServiceUnavailable({ message: "GitHub returned an incomplete changed-path observation" });
+	}
+	const paths = [
+		...new Set(files.flatMap((file) => (file.previousFilename === undefined ? [file.filename] : [file.previousFilename, file.filename]))),
+	];
+	return { head: after.head.sha, kind: "change" as const, paths, pr: after.htmlUrl, prNumber: after.number };
+});
+
+function validatePullRequest(pr: typeof PullRequest.Type, head: string, number: number, url: string, branch: string) {
+	const adoptable = (pr.state === "open" && !pr.merged) || (pr.state === "closed" && pr.merged);
+	if (!adoptable || pr.number !== number || pr.htmlUrl.toLowerCase() !== url.toLowerCase() || pr.base.ref !== branch) {
+		return Effect.fail(new BadRequest({ message: "Reported PR must be open or merged and target the configured repository branch" }));
+	}
+	return pr.head.sha === head
+		? Effect.void
+		: Effect.fail(
+				withFailureContext(
+					new Conflict({
+						message: pr.merged
+							? "Merged PR head differs from the reported head; inspect delivery before accepting this work"
+							: "PR head moved after the worker report",
+					}),
+					{ code: pr.merged ? "worker-report-merged-head-mismatch" : "worker-report-head-moved" },
+				),
+			);
+}

package/src/host/guidance.ts

@@ -0,0 +1,28 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Effect, FileSystem, Option, Path } from "effect";
+import { type FleetHost, HostFailure } from "#host/config.ts";
+
+export const hostGuidance = Effect.fn("FleetHost.hostGuidance")(function* (host: FleetHost, role: "worker" | "reviewer") {
+	const guidance = role === "worker" ? host.worker?.workerGuidance : host.worker?.reviewerGuidance;
+	if (guidance === undefined || typeof guidance === "string") {
+		return Effect.succeed(guidance);
+	}
+	const read = yield* Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		const file = path.resolve(host.boardDir, guidance.file);
+		let cached: { readonly modified: number; readonly text: string } | undefined;
+		return Effect.gen(function* () {
+			const stat = yield* fs.stat(file);
+			const modified = Option.getOrUndefined(stat.mtime)?.getTime();
+			if (modified !== undefined && cached?.modified === modified) {
+				return cached.text;
+			}
+			const text = yield* fs.readFileString(file);
+			cached = modified === undefined ? undefined : { modified, text };
+			return text;
+		}).pipe(Effect.mapError(() => new HostFailure({ message: `Fleet ${role} guidance is missing or unreadable: ${file}` })));
+	}).pipe(Effect.provide(NodeServices.layer));
+	yield* read;
+	return read;
+});

package/src/host/healthLayer.ts

@@ -0,0 +1,19 @@
+import { Effect, Layer, Ref, Schema } from "effect";
+import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
+import { Health } from "#engine/health.ts";
+import { ProviderCapacity } from "#session/schema.ts";
+
+const { fleetHealth } = diagnosticsApi;
+
+export function healthLayer(root: string) {
+	return Layer.effect(Health)(
+		Effect.gen(function* () {
+			const previous = yield* fleetHealth(root).pipe(Effect.option);
+			const rejection = previous._tag === "Some" ? previous.value.lastCapacityRejection : null;
+			return yield* Ref.make({
+				lastCapacityRejection: rejection !== null && Schema.decodeUnknownOption(ProviderCapacity)(rejection.cause)._tag === "Some" ? rejection : null,
+				lastSchedulerPass: previous._tag === "Some" ? previous.value.lastSchedulerPass : null,
+			});
+		}),
+	);
+}

package/src/host/localOnlyBoardPath.ts

@@ -0,0 +1,23 @@
+import { execFile } from "node:child_process";
+import { isAbsolute, relative, sep } from "node:path";
+import { Effect } from "effect";
+import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+
+export function localOnlyBoardPath(boardDir: string, repositoryRoot: string) {
+	const path = relative(repositoryRoot, boardDir);
+	if (path === "" || path === ".." || path.startsWith(`..${sep}`) || isAbsolute(path)) {
+		return Effect.succeed(undefined);
+	}
+	return Effect.callback<string | undefined, ServiceUnavailable>((resume) => {
+		const child = execFile("git", ["check-ignore", "--quiet", "--", `${path}${sep}`], { cwd: repositoryRoot, timeout: 10_000 }, (error) => {
+			if (error === null || error.code === 1) {
+				resume(Effect.succeed(error === null ? path.split(sep).join("/") : undefined));
+			} else {
+				resume(Effect.fail(new ServiceUnavailable({ message: `Cannot check whether the Board directory is git-ignored: ${error.message}` })));
+			}
+		});
+		return Effect.sync(() => {
+			child.kill();
+		});
+	});
+}

package/src/host/mainSource.ts

@@ -0,0 +1,97 @@
+import { execFile } from "node:child_process";
+import { Clock, Context, Effect, Layer } from "effect";
+import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { FleetError } from "#errors.ts";
+import type { FleetHost } from "#host/config.ts";
+import type { MainObservation, Preparation } from "#preparation/schema.ts";
+
+export interface MainSnapshot {
+	readonly observedAt: number;
+	readonly revision: string;
+}
+
+// One snapshot per scheduler pass keeps preparation and dispatch on the same main revision.
+export class MainSource extends Context.Service<
+	MainSource,
+	{
+		readonly current: Effect.Effect<MainSnapshot, FleetError>;
+		readonly observe: (preparation: Preparation) => Effect.Effect<MainObservation, FleetError>;
+		readonly refresh: Effect.Effect<MainSnapshot, FleetError>;
+		readonly repositoryRoot: string;
+	}
+>()("@shivaedev/work-fleet/host/MainSource") {}
+
+function git(cwd: string, args: readonly string[]) {
+	return Effect.callback<string, FleetError>((resume) => {
+		execFile("git", [...args], { cwd, timeout: 60_000 }, (error, stdout) => {
+			resume(
+				error === null ? Effect.succeed(stdout.trim()) : Effect.fail(new ServiceUnavailable({ message: `git ${args[0]} failed: ${error.message}` })),
+			);
+		});
+	});
+}
+
+export function gitMainSource(host: FleetHost) {
+	const GitMainSource = defineService({
+		id: "Fleet/GitMainSource",
+		initialize: Effect.gen(function* () {
+			const root = yield* git(host.boardDir, ["rev-parse", "--show-toplevel"]);
+			const ref = `${host.repository.remote}/${host.repository.branch}`;
+			let snapshot: MainSnapshot | undefined;
+			const refresh = Effect.gen(function* () {
+				yield* git(root, ["fetch", "--quiet", host.repository.remote, host.repository.branch]);
+				const next = { observedAt: yield* Clock.currentTimeMillis, revision: yield* git(root, ["rev-parse", ref]) };
+				snapshot = next;
+				return next;
+			});
+			const current = Effect.suspend(() => (snapshot === undefined ? refresh : Effect.succeed(snapshot)));
+			return { current, refresh, root };
+		}),
+		methods: ({ root, current, refresh }) => ({
+			current: () => current,
+			observe: (preparation: Preparation) =>
+				Effect.gen(function* () {
+					const main = yield* current;
+					if (main.revision === preparation.baseRevision) {
+						return unchanged(preparation.baseRevision, main);
+					}
+					const ancestor = yield* git(root, ["merge-base", "--is-ancestor", preparation.baseRevision, main.revision]).pipe(
+						Effect.as(true),
+						Effect.orElseSucceed(() => false),
+					);
+					const changed = yield* git(root, ["diff", "--name-only", preparation.baseRevision, main.revision]);
+					return {
+						ancestor,
+						changedPaths: changed.split("\n").filter((path) => path.length > 0),
+						complete: true,
+						configurationChanges: [],
+						fromRevision: preparation.baseRevision,
+						observedAt: main.observedAt,
+						revision: main.revision,
+					};
+				}),
+			refresh: () => refresh,
+			repositoryRoot: () => Effect.succeed(root),
+		}),
+		requires: [],
+	});
+	return Layer.effect(MainSource)(
+		Effect.gen(function* () {
+			const main = yield* GitMainSource;
+			return MainSource.of({ current: main.current(), observe: main.observe, refresh: main.refresh(), repositoryRoot: yield* main.repositoryRoot() });
+		}),
+	).pipe(Layer.provide(GitMainSource.layer));
+}
+
+export function unchanged(revision: string, main: MainSnapshot): MainObservation {
+	return {
+		ancestor: true,
+		changedPaths: [],
+		complete: true,
+		configurationChanges: [],
+		fromRevision: revision,
+		observedAt: main.observedAt,
+		revision,
+	};
+}

package/src/host/nameThreads.ts

@@ -0,0 +1,61 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Console, Effect, Layer } from "effect";
+import { FleetRepository, postgresFleetRepository } from "#engine/repository.ts";
+import { recordThreadNames } from "#engine/threadNames.ts";
+import { type FleetHost, HostFailure } from "#host/config.ts";
+import { hostProvider } from "#host/providers.ts";
+import { hostSql } from "#host/runtime.ts";
+import { SessionTransport } from "#session/service.ts";
+
+const nameThread = Effect.fn("FleetHost.nameThread")(function* (
+	transport: typeof SessionTransport.Service,
+	sessionId: string,
+	name: string,
+	desired: string,
+) {
+	if (transport.nameSession === undefined || transport.readSessionName === undefined) {
+		return yield* new HostFailure({ message: "The Cloud provider does not support thread names" });
+	}
+	if ((yield* transport.readSessionName(sessionId)) === desired) {
+		return false;
+	}
+	yield* transport.nameSession(sessionId, name);
+	return true;
+});
+
+function reportRename(workId: string, sessionId: string, desired: string, rename: Effect.Effect<boolean, { readonly message: string }>) {
+	return rename.pipe(
+		Effect.map((changed) => (changed ? [{ error: false, message: `${workId} ${sessionId}: renamed to ${desired}` }] : [])),
+		Effect.catch((error) => Effect.succeed([{ error: true, message: `${workId} ${sessionId}: naming failed: ${error.message}` }])),
+	);
+}
+
+export function nameThreads(host: FleetHost) {
+	const repository = postgresFleetRepository(host.namespace).pipe(Layer.provide(hostSql(host)));
+	return nameStoredThreads(host).pipe(
+		Effect.flatMap((results) => Effect.forEach(results, (result) => (result.error ? Console.error(result.message) : Console.log(result.message)))),
+		Effect.asVoid,
+		Effect.provide(Layer.mergeAll(repository, hostProvider(host), NodeServices.layer)),
+	);
+}
+
+export const nameStoredThreads = Effect.fn("FleetHost.nameStoredThreads")(function* (host: FleetHost) {
+	if (host.provider !== "cloud") {
+		return yield* Effect.fail(new HostFailure({ message: "name-threads requires a Cloud provider" }));
+	}
+	const transport = yield* SessionTransport;
+	const records = yield* (yield* FleetRepository).list();
+	const results: { readonly error: boolean; readonly message: string }[] = [];
+	const seen = new Set<string>();
+	for (const { value } of records) {
+		for (const [sessionId, name] of recordThreadNames(value)) {
+			if (seen.has(sessionId)) {
+				continue;
+			}
+			seen.add(sessionId);
+			const desired = `${host.cloud?.threadNamePrefix ?? "Fleet: "}${name}`;
+			results.push(...(yield* reportRename(value.workId, sessionId, desired, nameThread(transport, sessionId, name, desired))));
+		}
+	}
+	return results;
+});

package/src/host/providerHealth.ts

@@ -0,0 +1,57 @@
+import { Context, Effect, Layer, type Option } from "effect";
+import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { capacityRejected, Health } from "#engine/health.ts";
+import type { SessionFailure, SessionObservation } from "#session/schema.ts";
+import { SessionTransport } from "#session/service.ts";
+
+class ProviderHealthState extends Context.Service<ProviderHealthState, Option.Option<Health["Service"]>>()("Fleet/ProviderHealthState") {}
+const ProviderHealth = defineService({
+	id: "Fleet/ProviderHealth",
+	initialize: Effect.gen(function* () {
+		const transport = yield* SessionTransport;
+		const health = yield* ProviderHealthState;
+		const observed = new Set<string>();
+		function remember(key: string) {
+			observed.add(key);
+			if (observed.size > 1024) {
+				const oldest = observed.values().next().value;
+				if (oldest !== undefined) {
+					observed.delete(oldest);
+				}
+			}
+		}
+		function rejected(cause: NonNullable<SessionObservation["capacity"]>) {
+			return health._tag === "Some" ? capacityRejected(cause).pipe(Effect.provideService(Health, health.value)) : Effect.void;
+		}
+		function record<A>(effect: Effect.Effect<A, SessionFailure>) {
+			return effect.pipe(Effect.tapError((error) => (error.capacity === undefined ? Effect.void : rejected(error.capacity))));
+		}
+		return { observed, record, rejected, remember, transport };
+	}),
+	methods: ({ transport, record, observed, remember, rejected }) =>
+		SessionTransport.of({
+			...transport,
+			observe: (receipt) =>
+				record(transport.observe(receipt)).pipe(
+					Effect.tap((observation) => {
+						const key = `${receipt.sessionId}/${receipt.turnId}`;
+						if (observation.capacity === undefined || observed.has(key)) {
+							return Effect.void;
+						}
+						remember(key);
+						return rejected(observation.capacity);
+					}),
+				),
+			startSession: (input) => record(transport.startSession(input)),
+			startTurn: (input) => record(transport.startTurn(input)),
+		}),
+	requires: [SessionTransport, ProviderHealthState],
+});
+
+export const providerHealth = Layer.unwrap(
+	Effect.map(Effect.serviceOption(Health), (health) =>
+		Layer.effect(SessionTransport)(ProviderHealth).pipe(
+			Layer.provide(ProviderHealth.layer.pipe(Layer.provide(Layer.succeed(ProviderHealthState, health)))),
+		),
+	),
+);

package/src/host/providers.ts

@@ -0,0 +1,34 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Effect, Layer } from "effect";
+import { type FleetHost, HostFailure } from "#host/config.ts";
+import { CodexCloudConfig, codexCloudLayer } from "#providers/codexCloud.ts";
+import { CodexLocalConfig, codexLocalLayer } from "#providers/codexLocal.ts";
+import { SessionTransport } from "#session/service.ts";
+
+export function hostProvider(host: FleetHost) {
+	switch (host.provider) {
+		case "local": {
+			if (host.local === undefined) {
+				return Layer.effect(SessionTransport)(
+					Effect.fail(new HostFailure({ message: 'provider "local" needs local.endpoint in the host configuration' })),
+				);
+			}
+			return codexLocalLayer.pipe(
+				Layer.provide(Layer.succeed(CodexLocalConfig)({ endpoint: host.local.endpoint, requestTimeoutMs: host.local.requestTimeoutMs ?? 30_000 })),
+			);
+		}
+		case "cloud": {
+			if (host.cloud === undefined) {
+				return Layer.effect(SessionTransport)(
+					Effect.fail(new HostFailure({ message: 'provider "cloud" needs cloud settings in the host configuration' })),
+				);
+			}
+			const { requestTimeoutMs = 60_000, ...cloud } = host.cloud;
+			return codexCloudLayer.pipe(Layer.provide([Layer.succeed(CodexCloudConfig)({ ...cloud, requestTimeoutMs }), NodeServices.layer]));
+		}
+	}
+}
+
+export function workerCwd(host: FleetHost, repositoryRoot: string) {
+	return host.provider === "cloud" && host.cloud !== undefined ? host.cloud.cwd : repositoryRoot;
+}

package/src/host/quota.ts

@@ -0,0 +1,46 @@
+import { Effect, Schema } from "effect";
+import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
+import type { FleetError } from "#errors.ts";
+import type { FleetHost } from "#host/config.ts";
+import type { FleetConfiguration } from "#policy.ts";
+
+const { codexRateLimits } = diagnosticsApi;
+
+type Quota = FleetConfiguration["quota"];
+
+const OBSERVATION_MS = 60_000;
+// Admission counts submissions against this; while ordinary usage is allowed the provider imposes no smaller number.
+const ORDINARY_USAGE = Number.MAX_SAFE_INTEGER;
+
+const RateLimits = Schema.Struct({ ordinaryUsageAllowed: Schema.Boolean });
+
+export function unlimitedQuota(now: () => number): Effect.Effect<Quota> {
+	return Effect.sync(() => {
+		const observedAt = now();
+		return { available: ORDINARY_USAGE, expiresAt: observedAt + OBSERVATION_MS, observedAt };
+	});
+}
+
+export function codexQuota(
+	now: () => number,
+	read: Effect.Effect<unknown, FleetError> = codexRateLimits().pipe(Effect.mapError((error) => new ServiceUnavailable({ message: error.message }))),
+): () => Effect.Effect<Quota, FleetError> {
+	let cached: Quota | undefined;
+	return () =>
+		Effect.gen(function* () {
+			if (cached !== undefined && cached.expiresAt > now()) {
+				return cached;
+			}
+			const limits = yield* Schema.decodeUnknownEffect(RateLimits)(yield* read).pipe(
+				Effect.mapError(() => new ServiceUnavailable({ message: "Codex rate limits returned an unknown shape" })),
+			);
+			const observedAt = now();
+			cached = { available: limits.ordinaryUsageAllowed ? ORDINARY_USAGE : 0, expiresAt: observedAt + OBSERVATION_MS, observedAt };
+			return cached;
+		});
+}
+
+export function hostQuota(host: FleetHost, now: () => number): () => Effect.Effect<Quota, FleetError> {
+	return host.quota === "unlimited" ? () => unlimitedQuota(now) : codexQuota(now);
+}

package/src/host/readCommand.ts

@@ -0,0 +1,25 @@
+import { Effect, Stream } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+
+export function readCommand(command: string, args: readonly string[], cwd?: string, input?: string) {
+	return Effect.scoped(
+		Effect.gen(function* () {
+			const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+			const process = yield* spawner.spawn(
+				ChildProcess.make(command, args, {
+					...(cwd === undefined ? {} : { cwd }),
+					...(input === undefined ? {} : { stdin: Stream.make(new TextEncoder().encode(input)) }),
+				}),
+			);
+			const output = yield* process.stdout.pipe(Stream.decodeText, Stream.mkString);
+			if ((yield* process.exitCode) !== 0) {
+				return yield* Effect.fail(new ServiceUnavailable({ message: `${command} could not read report evidence` }));
+			}
+			return output;
+		}),
+	).pipe(
+		Effect.timeout("60 seconds"),
+		Effect.mapError(() => new ServiceUnavailable({ message: `${command} could not read report evidence` })),
+	);
+}