@kodrunhq/opencode-autopilot 1.18.0 → 1.19.0

package/src/autonomy/verification.ts

@@ -0,0 +1,86 @@
+import { access } from "node:fs/promises";
+import type { LoopContext, VerificationCheck, VerificationResult } from "./types";
+
+export interface CommandExecutionResult {
+	readonly exitCode: number;
+	readonly output: string;
+}
+
+export interface VerificationHandlerDeps {
+	readonly runCommand?: (command: string) => Promise<CommandExecutionResult>;
+	readonly artifactPaths?: readonly string[];
+}
+
+function createCheck(name: string, passed: boolean, message: string): VerificationCheck {
+	return Object.freeze({ name, passed, message });
+}
+
+export class VerificationHandler {
+	constructor(private readonly deps: VerificationHandlerDeps = {}) {}
+
+	async verify(_context: LoopContext): Promise<VerificationResult> {
+		const checks = await Promise.all([
+			this.checkTestsPass(),
+			this.checkLintClean(),
+			this.checkArtifactsExist(this.deps.artifactPaths ?? []),
+		]);
+
+		return Object.freeze({
+			passed: checks.every((check) => check.passed),
+			checks: Object.freeze(checks),
+			timestamp: new Date().toISOString(),
+		});
+	}
+
+	async checkTestsPass(): Promise<VerificationCheck> {
+		return this.runCommandCheck("tests", "bun test");
+	}
+
+	async checkLintClean(): Promise<VerificationCheck> {
+		return this.runCommandCheck("lint", "bun run lint");
+	}
+
+	async checkArtifactsExist(paths: readonly string[]): Promise<VerificationCheck> {
+		if (paths.length === 0) {
+			return createCheck("artifacts", true, "No artifact paths configured");
+		}
+
+		try {
+			const missingPaths: string[] = [];
+			for (const path of paths) {
+				try {
+					await access(path);
+				} catch {
+					missingPaths.push(path);
+				}
+			}
+
+			if (missingPaths.length > 0) {
+				return createCheck("artifacts", false, `Missing artifacts: ${missingPaths.join(", ")}`);
+			}
+
+			return createCheck("artifacts", true, `Verified ${paths.length} artifact(s)`);
+		} catch (error: unknown) {
+			const message = error instanceof Error ? error.message : String(error);
+			return createCheck("artifacts", false, `Artifact check failed: ${message}`);
+		}
+	}
+
+	private async runCommandCheck(name: string, command: string): Promise<VerificationCheck> {
+		if (!this.deps.runCommand) {
+			return createCheck(name, true, `Skipped ${command}: no command runner configured`);
+		}
+
+		try {
+			const result = await this.deps.runCommand(command);
+			if (result.exitCode === 0) {
+				return createCheck(name, true, `${command} passed`);
+			}
+
+			return createCheck(name, false, `${command} failed: ${result.output}`);
+		} catch (error: unknown) {
+			const message = error instanceof Error ? error.message : String(error);
+			return createCheck(name, false, `${command} failed: ${message}`);
+		}
+	}
+}

package/src/background/database.ts

@@ -0,0 +1,170 @@
+import type { Database } from "bun:sqlite";
+import { randomUUID } from "node:crypto";
+import { type TaskStatus, TaskStatusSchema } from "../types/background";
+
+export const ACTIVE_TASK_STATUSES = Object.freeze(["pending", "running"] as const);
+export const TERMINAL_TASK_STATUSES = Object.freeze(["completed", "failed", "cancelled"] as const);
+
+export interface BackgroundTaskRecord {
+	readonly id: string;
+	readonly sessionId: string;
+	readonly description: string;
+	readonly category: string | null;
+	readonly status: TaskStatus;
+	readonly result: string | null;
+	readonly error: string | null;
+	readonly agent: string | null;
+	readonly model: string | null;
+	readonly priority: number;
+	readonly createdAt: string;
+	readonly updatedAt: string;
+	readonly startedAt: string | null;
+	readonly completedAt: string | null;
+}
+
+export interface CreateBackgroundTaskInput {
+	readonly id?: string;
+	readonly sessionId: string;
+	readonly description: string;
+	readonly category?: string | null;
+	readonly status?: TaskStatus;
+	readonly result?: string | null;
+	readonly error?: string | null;
+	readonly agent?: string | null;
+	readonly model?: string | null;
+	readonly priority?: number;
+	readonly createdAt?: string;
+	readonly updatedAt?: string;
+	readonly startedAt?: string | null;
+	readonly completedAt?: string | null;
+}
+
+export interface BackgroundTaskResultRecord {
+	readonly status: TaskStatus;
+	readonly result: string | null;
+	readonly error: string | null;
+	readonly completedAt: string | null;
+}
+
+interface BackgroundTaskRow {
+	readonly id: string;
+	readonly session_id: string;
+	readonly description: string;
+	readonly category: string | null;
+	readonly status: string;
+	readonly result: string | null;
+	readonly error: string | null;
+	readonly agent: string | null;
+	readonly model: string | null;
+	readonly priority: number;
+	readonly created_at: string;
+	readonly updated_at: string;
+	readonly started_at: string | null;
+	readonly completed_at: string | null;
+}
+
+function isClosedDatabaseError(error: unknown): boolean {
+	return (
+		error instanceof RangeError &&
+		typeof error.message === "string" &&
+		error.message.includes("closed database")
+	);
+}
+
+export function createTaskId(): string {
+	return randomUUID();
+}
+
+export function createTimestamp(now: () => string = () => new Date().toISOString()): string {
+	return now();
+}
+
+export function parseTaskStatus(value: unknown): TaskStatus {
+	return TaskStatusSchema.parse(value);
+}
+
+export function rowToBackgroundTask(row: BackgroundTaskRow): BackgroundTaskRecord {
+	return Object.freeze({
+		id: row.id,
+		sessionId: row.session_id,
+		description: row.description,
+		category: row.category,
+		status: parseTaskStatus(row.status),
+		result: row.result,
+		error: row.error,
+		agent: row.agent,
+		model: row.model,
+		priority: row.priority,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		startedAt: row.started_at,
+		completedAt: row.completed_at,
+	});
+}
+
+export function getTaskByIdRow(db: Database, taskId: string): BackgroundTaskRecord | null {
+	try {
+		const row = db
+			.query("SELECT * FROM background_tasks WHERE id = ?")
+			.get(taskId) as BackgroundTaskRow | null;
+		return row ? rowToBackgroundTask(row) : null;
+	} catch (error: unknown) {
+		if (isClosedDatabaseError(error)) {
+			return null;
+		}
+		throw error;
+	}
+}
+
+export interface ListBackgroundTasksFilters {
+	readonly sessionId?: string;
+	readonly status?: TaskStatus;
+	readonly statuses?: readonly TaskStatus[];
+	readonly limit?: number;
+	readonly prioritizePending?: boolean;
+}
+
+export function listBackgroundTasks(
+	db: Database,
+	filters: ListBackgroundTasksFilters = {},
+): readonly BackgroundTaskRecord[] {
+	const conditions: string[] = [];
+	const params: Array<string | number> = [];
+
+	if (filters.sessionId) {
+		conditions.push("session_id = ?");
+		params.push(filters.sessionId);
+	}
+
+	if (filters.status) {
+		conditions.push("status = ?");
+		params.push(filters.status);
+	}
+
+	if (filters.statuses && filters.statuses.length > 0) {
+		const placeholders = filters.statuses.map(() => "?").join(", ");
+		conditions.push(`status IN (${placeholders})`);
+		params.push(...filters.statuses);
+	}
+
+	const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+	const orderBy = filters.prioritizePending
+		? "ORDER BY priority DESC, created_at ASC, id ASC"
+		: "ORDER BY created_at DESC, id DESC";
+	const limitClause = typeof filters.limit === "number" ? " LIMIT ?" : "";
+	const query = `SELECT * FROM background_tasks ${whereClause} ${orderBy}${limitClause}`;
+
+	if (typeof filters.limit === "number") {
+		params.push(filters.limit);
+	}
+
+	try {
+		const rows = db.query(query).all(...params) as BackgroundTaskRow[];
+		return Object.freeze(rows.map(rowToBackgroundTask));
+	} catch (error: unknown) {
+		if (isClosedDatabaseError(error)) {
+			return Object.freeze([]);
+		}
+		throw error;
+	}
+}

package/src/background/executor.ts

@@ -0,0 +1,174 @@
+import type { Logger } from "../logging/types";
+import type { TaskStatus } from "../types/background";
+import type { BackgroundTaskRecord } from "./database";
+
+export interface ExecuteTaskStatusPayload {
+	readonly result?: string | null;
+	readonly error?: string | null;
+}
+
+export interface ExecuteTaskDependencies {
+	readonly updateStatus: (
+		taskId: string,
+		status: TaskStatus,
+		payload?: ExecuteTaskStatusPayload,
+	) => void | Promise<void>;
+	readonly logger?: Logger;
+	readonly wait?: (durationMs: number, signal: AbortSignal) => Promise<void>;
+	readonly run?: (
+		task: BackgroundTaskRecord,
+		signal: AbortSignal,
+	) => Promise<string | null | undefined>;
+	readonly getTaskById?: (taskId: string) => BackgroundTaskRecord | null;
+	readonly timeoutMs?: number;
+	readonly executionDelayMs?: number;
+	readonly pollIntervalMs?: number;
+}
+
+export interface ExecuteTaskResult {
+	readonly taskId: string;
+	readonly status: TaskStatus;
+	readonly result?: string;
+	readonly error?: string;
+}
+
+function createAbortError(message: string): Error {
+	const error = new Error(message);
+	Object.defineProperty(error, "name", { value: "AbortError" });
+	return error;
+}
+
+function isAbortError(error: unknown): boolean {
+	return error instanceof Error && error.name === "AbortError";
+}
+
+function getDefaultRunner(
+	wait: (durationMs: number, signal: AbortSignal) => Promise<void>,
+	delayMs: number,
+): (task: BackgroundTaskRecord, signal: AbortSignal) => Promise<string> {
+	return async (task, signal) => {
+		await wait(delayMs, signal);
+		const agentSuffix = task.agent ? ` [agent=${task.agent}]` : "";
+		const modelSuffix = task.model ? ` [model=${task.model}]` : "";
+		return `Completed background task: ${task.description}${agentSuffix}${modelSuffix}`;
+	};
+}
+
+async function defaultWait(durationMs: number, signal: AbortSignal): Promise<void> {
+	await new Promise<void>((resolve, reject) => {
+		if (signal.aborted) {
+			reject(signal.reason ?? createAbortError("Aborted"));
+			return;
+		}
+
+		const timeoutId = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, durationMs);
+
+		const onAbort = () => {
+			clearTimeout(timeoutId);
+			reject(signal.reason ?? createAbortError("Aborted"));
+		};
+
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+
+function getCancellationState(
+	taskId: string,
+	getTaskById?: (taskId: string) => BackgroundTaskRecord | null,
+): BackgroundTaskRecord | null {
+	if (!getTaskById) {
+		return null;
+	}
+
+	const currentTask = getTaskById(taskId);
+	return currentTask?.status === "cancelled" ? currentTask : null;
+}
+
+export async function executeTask(
+	task: BackgroundTaskRecord,
+	deps: ExecuteTaskDependencies,
+): Promise<ExecuteTaskResult> {
+	const logger = deps.logger;
+	const cancelledBeforeStart = getCancellationState(task.id, deps.getTaskById);
+	if (cancelledBeforeStart) {
+		logger?.info("Background task already cancelled before execution", {
+			backgroundTaskId: task.id,
+		});
+		return { taskId: task.id, status: "cancelled" };
+	}
+
+	await deps.updateStatus(task.id, "running");
+	logger?.info("Background task started", { backgroundTaskId: task.id });
+
+	const controller = new AbortController();
+	const timeoutMs = deps.timeoutMs ?? 1_000;
+	const executionDelayMs = deps.executionDelayMs ?? 10;
+	const wait = deps.wait ?? defaultWait;
+	const run = deps.run ?? getDefaultRunner(wait, executionDelayMs);
+
+	let timedOut = false;
+	const timeoutId = setTimeout(() => {
+		timedOut = true;
+		controller.abort(createAbortError(`Background task timed out after ${timeoutMs}ms`));
+	}, timeoutMs);
+
+	const pollIntervalMs = deps.pollIntervalMs ?? 10;
+	const cancellationIntervalId = deps.getTaskById
+		? setInterval(() => {
+				const cancelledTask = getCancellationState(task.id, deps.getTaskById);
+				if (cancelledTask && !controller.signal.aborted) {
+					controller.abort(createAbortError("Background task cancelled"));
+				}
+			}, pollIntervalMs)
+		: null;
+
+	try {
+		const result = await run(task, controller.signal);
+		const cancelledTask = getCancellationState(task.id, deps.getTaskById);
+		if (cancelledTask) {
+			logger?.info("Background task cancelled during execution", {
+				backgroundTaskId: task.id,
+			});
+			return { taskId: task.id, status: "cancelled" };
+		}
+
+		const message = result ?? `Completed background task: ${task.description}`;
+		await deps.updateStatus(task.id, "completed", { result: message });
+		logger?.info("Background task completed", { backgroundTaskId: task.id });
+		return { taskId: task.id, status: "completed", result: message };
+	} catch (error: unknown) {
+		const cancelledTask = getCancellationState(task.id, deps.getTaskById);
+		if (cancelledTask) {
+			logger?.info("Background task observed cancellation", {
+				backgroundTaskId: task.id,
+			});
+			return { taskId: task.id, status: "cancelled" };
+		}
+
+		if (timedOut && isAbortError(error)) {
+			const message = error instanceof Error ? error.message : "Background task timed out";
+			await deps.updateStatus(task.id, "failed", { error: message });
+			logger?.error("Background task timed out", {
+				backgroundTaskId: task.id,
+				error: message,
+			});
+			return { taskId: task.id, status: "failed", error: message };
+		}
+
+		const message = error instanceof Error ? error.message : String(error);
+		await deps.updateStatus(task.id, "failed", { error: message });
+		logger?.error("Background task failed", {
+			backgroundTaskId: task.id,
+			error: message,
+		});
+		return { taskId: task.id, status: "failed", error: message };
+	} finally {
+		clearTimeout(timeoutId);
+		if (cancellationIntervalId !== null) {
+			clearInterval(cancellationIntervalId);
+		}
+	}
+}

package/src/background/index.ts

@@ -0,0 +1,8 @@
+export * from "./database";
+export * from "./executor";
+export * from "./manager";
+export * from "./repository";
+export * from "./schema";
+export * from "./sdk-runner";
+export * from "./slot-manager";
+export * from "./state-machine";

package/src/background/manager.ts

@@ -0,0 +1,232 @@
+import type { Database } from "bun:sqlite";
+import { getLogger } from "../logging/domains";
+import type { Logger } from "../logging/types";
+import type { TaskStatus } from "../types/background";
+import type { BackgroundTaskRecord, BackgroundTaskResultRecord } from "./database";
+import { listBackgroundTasks } from "./database";
+import { type ExecuteTaskDependencies, type ExecuteTaskResult, executeTask } from "./executor";
+import {
+	cancelTask,
+	createTask,
+	getActiveTasks,
+	getTaskById,
+	getTaskResult,
+	listTasks,
+	updateStatus,
+} from "./repository";
+import { SlotManager } from "./slot-manager";
+
+function isClosedDatabaseError(error: unknown): boolean {
+	return (
+		error instanceof RangeError &&
+		typeof error.message === "string" &&
+		error.message.includes("closed database")
+	);
+}
+
+export interface BackgroundSpawnOptions {
+	readonly category?: string;
+	readonly agent?: string;
+	readonly model?: string;
+	readonly priority?: number;
+	readonly timeoutMs?: number;
+	readonly executionDelayMs?: number;
+}
+
+export interface BackgroundManagerOptions {
+	readonly db: Database;
+	readonly maxConcurrent?: number;
+	readonly logger?: Logger;
+	readonly executor?: (
+		task: BackgroundTaskRecord,
+		deps: ExecuteTaskDependencies,
+	) => Promise<ExecuteTaskResult>;
+	readonly runTask?: ExecuteTaskDependencies["run"];
+	readonly wait?: ExecuteTaskDependencies["wait"];
+	readonly timeoutMs?: number;
+	readonly executionDelayMs?: number;
+}
+
+interface RunningTaskEntry {
+	readonly slotId: string;
+	readonly promise: Promise<void>;
+}
+
+export class BackgroundManager {
+	private readonly maxConcurrent: number;
+	private readonly logger: Logger;
+	private readonly slotManager: SlotManager;
+	private readonly runningTasks = new Map<string, RunningTaskEntry>();
+	private readonly execute: (
+		task: BackgroundTaskRecord,
+		deps: ExecuteTaskDependencies,
+	) => Promise<ExecuteTaskResult>;
+	private disposed = false;
+	private isPumping = false;
+
+	constructor(private readonly options: BackgroundManagerOptions) {
+		this.maxConcurrent = options.maxConcurrent ?? 5;
+		this.logger = options.logger ?? getLogger("background", "manager");
+		this.slotManager = new SlotManager(this.maxConcurrent);
+		this.execute = options.executor ?? executeTask;
+	}
+
+	spawn(sessionId: string, description: string, options: BackgroundSpawnOptions = {}): string {
+		if (this.disposed) {
+			throw new Error("BackgroundManager is disposed");
+		}
+
+		const task = createTask(this.options.db, {
+			sessionId,
+			description,
+			category: options.category,
+			agent: options.agent,
+			model: options.model,
+			priority: options.priority,
+		});
+		this.logger.info("Background task queued", {
+			backgroundTaskId: task.id,
+			sessionId,
+			description,
+		});
+		queueMicrotask(() => {
+			void this.pumpQueue();
+		});
+		return task.id;
+	}
+
+	async waitForIdle(timeoutMs = 1_000): Promise<void> {
+		const startedAt = Date.now();
+		while (true) {
+			await Promise.resolve();
+			const hasPendingTasks =
+				listBackgroundTasks(this.options.db, { status: "pending", limit: 1 }).length > 0;
+			const isIdle = this.runningTasks.size === 0 && !hasPendingTasks;
+			if (isIdle) {
+				return;
+			}
+
+			if (Date.now() - startedAt > timeoutMs) {
+				throw new Error("Timed out waiting for background manager to become idle");
+			}
+
+			await new Promise((resolve) => setTimeout(resolve, 5));
+		}
+	}
+
+	async dispose(): Promise<void> {
+		await this.waitForIdle();
+		this.disposed = true;
+	}
+
+	cancel(taskId: string): boolean {
+		const task = getTaskById(this.options.db, taskId);
+		if (!task) {
+			return false;
+		}
+
+		if (task.status !== "pending" && task.status !== "running") {
+			return false;
+		}
+
+		cancelTask(this.options.db, taskId);
+		this.logger.info("Background task cancelled", { backgroundTaskId: taskId });
+		return true;
+	}
+
+	cancelAll(sessionId?: string): number {
+		const activeTasks = getActiveTasks(this.options.db, sessionId);
+		let cancelledCount = 0;
+		for (const task of activeTasks) {
+			if (this.cancel(task.id)) {
+				cancelledCount += 1;
+			}
+		}
+		return cancelledCount;
+	}
+
+	getStatus(taskId: string): BackgroundTaskRecord | null {
+		return getTaskById(this.options.db, taskId);
+	}
+
+	list(sessionId?: string, statusFilter?: TaskStatus): readonly BackgroundTaskRecord[] {
+		return listTasks(this.options.db, { sessionId, status: statusFilter });
+	}
+
+	getResult(taskId: string): BackgroundTaskResultRecord | null {
+		return getTaskResult(this.options.db, taskId);
+	}
+
+	private async pumpQueue(): Promise<void> {
+		if (this.disposed || this.isPumping) {
+			return;
+		}
+
+		this.isPumping = true;
+		try {
+			while (!this.slotManager.isFull()) {
+				const nextTask = listBackgroundTasks(this.options.db, {
+					status: "pending",
+					limit: 1,
+					prioritizePending: true,
+				})[0];
+				if (!nextTask || this.runningTasks.has(nextTask.id)) {
+					break;
+				}
+
+				const slotId = this.slotManager.acquire();
+				if (!slotId) {
+					break;
+				}
+
+				const promise = this.runTask(nextTask, slotId);
+				this.runningTasks.set(nextTask.id, { slotId, promise });
+			}
+		} finally {
+			this.isPumping = false;
+		}
+	}
+
+	private async runTask(task: BackgroundTaskRecord, slotId: string): Promise<void> {
+		try {
+			await this.execute(task, {
+				updateStatus: (taskId, status, payload) => {
+					try {
+						updateStatus(this.options.db, taskId, status, payload);
+					} catch (error: unknown) {
+						if (!isClosedDatabaseError(error)) {
+							throw error;
+						}
+					}
+				},
+				getTaskById: (taskId) => {
+					try {
+						return getTaskById(this.options.db, taskId);
+					} catch (error: unknown) {
+						if (isClosedDatabaseError(error)) {
+							return null;
+						}
+						throw error;
+					}
+				},
+				logger: this.logger.child({ backgroundTaskId: task.id, slotId }),
+				run: this.options.runTask,
+				wait: this.options.wait,
+				timeoutMs: this.options.timeoutMs,
+				executionDelayMs: this.options.executionDelayMs,
+			});
+		} catch (error: unknown) {
+			if (!isClosedDatabaseError(error)) {
+				throw error;
+			}
+		} finally {
+			this.runningTasks.delete(task.id);
+			this.slotManager.release(slotId);
+			queueMicrotask(() => {
+				if (!this.disposed) {
+					void this.pumpQueue();
+				}
+			});
+		}
+	}
+}