A personal agent with a browser, terminal, files, and work that keeps going built with CopilotKit and AG-UI.
TypeScript
import { randomUUID } from "node:crypto";
import type { AgentTask, RunEvent } from "../../../../packages/domain/src/agent.ts";
import type { Store } from "../db.ts";
import { backgroundFailure } from "../log.ts";
export class LostLeaseError extends Error {
constructor() {
super("Task was paused, cancelled or taken over by another worker");
this.name = "LostLeaseError";
}
}
export interface TaskContext {
signal: AbortSignal;
guard(): Promise<void>;
checkpoint(patch: Partial<AgentTask>): Promise<AgentTask>;
event(kind: RunEvent["kind"], title: string, detail?: string): Promise<void>;
}
export type TaskHandler = (
owner: string,
task: AgentTask,
context: TaskContext,
) => Promise<Partial<AgentTask>>;
export class TaskWorker {
private timer?: ReturnType<typeof setInterval>;
private ticking = false;
private stopping = false;
private active = new Map<string, AbortController>();
// Tasks this worker has started and not yet settled, including ones still being claimed.
private inFlight = new Set<string>();
lastTickAt?: string;
constructor(
private readonly db: Store,
private readonly execute: TaskHandler,
private readonly options: {
now?: () => number;
leaseMs?: number;
pollMs?: number;
settled?: (owner: string, task: AgentTask) => Promise<void>;
} = {},
) {}
private now() {
return this.options.now?.() ?? Date.now();
}
get running() {
return Boolean(this.timer);
}
start() {
if (this.timer) return;
this.stopping = false;
this.timer = setInterval(() => {
// Timer callbacks cannot await runs; each run owns its durable error state.
void this.tick().catch((error) => backgroundFailure("task worker tick", error));
}, this.options.pollMs ?? 1000);
void this.tick().catch((error) => backgroundFailure("initial task worker tick", error));
}
async stop() {
this.stopping = true;
if (this.timer) clearInterval(this.timer);
this.timer = undefined;
for (const controller of this.active.values()) controller.abort();
while (this.inFlight.size || this.ticking) await new Promise((r) => setTimeout(r, 10));
}
abort(taskId: string) {
this.active.get(taskId)?.abort();
}
async tick() {
if (this.stopping) return;
if (this.running)
await this.db.put("system", "worker-status", {
id: "tasks",
lastTickAt: new Date(this.now()).toISOString(),
});
if (this.ticking) return;
this.ticking = true;
this.lastTickAt = new Date(this.now()).toISOString();
const started: Promise<void>[] = [];
try {
const records = await this.db.scan<AgentTask>("tasks");
const due = records.filter(
({ value: t }) =>
!this.inFlight.has(t.id) &&
(t.status === "queued" ||
(t.status === "scheduled" && Date.parse(t.nextRunAt ?? "") <= this.now()) ||
(t.status === "running" && Date.parse(t.leaseUntil ?? "") <= this.now()) ||
t.status === "waiting_approval"),
);
const eligible = [];
for (const record of due) {
if (this.inFlight.size + eligible.length >= 3) break;
if (record.value.status === "waiting_approval") {
const action = record.value.actionId
? await this.db.get<{ status: string; expiresAt?: string }>(
record.owner,
"actions",
record.value.actionId,
)
: null;
if (
record.value.actionId &&
action?.status === "awaiting_review" &&
Date.parse(action.expiresAt ?? "") <= this.now()
)
await this.db.compareAndSwap(
record.owner,
"actions",
record.value.actionId,
{ status: "awaiting_review", expiresAt: action.expiresAt },
{ status: "expired" },
);
else if (action && ["awaiting_review", "executing"].includes(action.status)) continue;
}
eligible.push(record);
}
// Runs outlive the tick, so a long task does not stop later ticks from starting queued work.
for (const { owner, value } of eligible) {
this.inFlight.add(value.id);
started.push(this.run(owner, value).finally(() => this.inFlight.delete(value.id)));
}
} finally {
this.ticking = false;
}
await Promise.all(started);
}
private async run(owner: string, previous: AgentTask) {
if (this.stopping) return;
const leaseId = randomUUID(),
leaseMs = this.options.leaseMs ?? 60000;
const expected: Record<string, unknown> = {
status: previous.status,
leaseId: previous.leaseId ?? null,
};
if (previous.status === "running") expected.leaseUntil = previous.leaseUntil;
let task = await this.db.compareAndSwap<AgentTask>(owner, "tasks", previous.id, expected, {
status: "running",
leaseId,
leaseUntil: new Date(this.now() + leaseMs).toISOString(),
updatedAt: new Date(this.now()).toISOString(),
attempts: previous.attempts + 1,
});
if (!task) return;
const controller = new AbortController();
this.active.set(task.id, controller);
const taskId = task.id;
const guard = async () => {
const latest = await this.db.get<AgentTask>(owner, "tasks", taskId);
if (controller.signal.aborted || latest?.leaseId !== leaseId || latest.status !== "running")
throw new LostLeaseError();
};
const checkpoint = async (patch: Partial<AgentTask>) => {
if (controller.signal.aborted) throw new LostLeaseError();
const next = await this.db.compareAndSwap<AgentTask>(
owner,
"tasks",
taskId,
{ leaseId, status: "running" },
{ ...patch, updatedAt: new Date(this.now()).toISOString() },
);
if (!next) throw new LostLeaseError();
task = next;
return next;
};
const event = async (kind: RunEvent["kind"], title: string, detail = "") => {
await guard();
await this.db.put(owner, "run-events", {
id: randomUUID(),
taskId,
date: new Date(this.now()).toISOString(),
kind,
title,
detail,
});
};
const startedAt = new Date(this.now()).toISOString();
const heartbeat = setInterval(
() => {
void this.db
.compareAndSwap(
owner,
"tasks",
taskId,
{ leaseId, status: "running" },
{ leaseUntil: new Date(this.now() + leaseMs).toISOString() },
)
.then((value) => {
if (!value) controller.abort();
})
.catch(() => controller.abort());
},
Math.max(10, Math.floor(leaseMs / 3)),
);
try {
await this.db.put(owner, "runs", {
id: leaseId,
taskId,
startedAt,
status: "running",
});
const result = await this.execute(owner, task, {
signal: controller.signal,
guard,
checkpoint,
event,
});
await checkpoint({ ...result, leaseId: null, leaseUntil: null });
await this.db.put(owner, "runs", {
id: leaseId,
taskId,
startedAt,
finishedAt: new Date(this.now()).toISOString(),
status: result.status ?? task.status,
});
} catch (error) {
if (error instanceof LostLeaseError || controller.signal.aborted) {
await this.db.compareAndSwap(
owner,
"tasks",
taskId,
{ leaseId, status: "running" },
{ status: "queued", leaseId: null, leaseUntil: null },
);
} else {
const detail = error instanceof Error ? error.message : "Task execution failed";
await event("error", "Task needs attention", detail).catch((error) =>
backgroundFailure("record task error", error),
);
await this.db.compareAndSwap(
owner,
"tasks",
taskId,
{ leaseId, status: "running" },
{
status: "failed",
error: detail,
leaseId: null,
leaseUntil: null,
updatedAt: new Date(this.now()).toISOString(),
},
);
}
await this.db.compareAndSwap(
owner,
"runs",
leaseId,
{ status: "running" },
{
status: controller.signal.aborted ? "interrupted" : "failed",
finishedAt: new Date(this.now()).toISOString(),
},
);
} finally {
clearInterval(heartbeat);
this.active.delete(taskId);
}
const settled = await this.db.get<AgentTask>(owner, "tasks", taskId);
if (settled && this.options.settled) await this.options.settled(owner, settled);
}
}