Skip to content

A personal agent with a browser, terminal, files, and work that keeps going built with CopilotKit and AG-UI.

TypeScript

fix: resume monitors from Activity through the recoverable transition (#82)

wangtao504a3ac43b2f
diff --git a/apps/server/src/engine/service.ts b/apps/server/src/engine/service.ts
index e0003c9..9f8f24a 100644
--- a/apps/server/src/engine/service.ts
+++ b/apps/server/src/engine/service.ts
@@ -244,6 +244,20 @@ export class AgentService {
if (action === "resume" && task.status !== "paused")
throw new AppError("Only paused tasks can be resumed", 409);
if (action === "pause" && (terminal.has(task.status) || task.status === "paused")) return task;
+ if (task.kind === "monitor" && action === "resume") {
+ // Both UI entry points must activate the monitor before a worker can claim its task.
+ await this.controlMonitor(owner, String(task.input.monitorId), "resume");
+ const resumed = await this.getTask(owner, id);
+ await this.db.put(owner, "run-events", {
+ id: randomUUID(),
+ taskId: id,
+ kind: "status",
+ date: date(),
+ title: `Task ${resumed.status}`,
+ detail: "Changed by you",
+ });
+ return resumed;
+ }
const status =
action === "cancel"
? "cancelled"
@@ -277,9 +291,6 @@ export class AgentService {
: action === "pause"
? "Paused. Resume when you're ready."
: "",
- ...(task.kind === "monitor" && action === "resume"
- ? { state: { ...task.state, failures: 0, notice: null, resumingMonitor: false } }
- : {}),
},
);
if (!updated) throw new AppError("Task changed; refresh and try again", 409);
diff --git a/tests/monitor-recovery.test.ts b/tests/monitor-recovery.test.ts
index a989944..2312ce0 100644
--- a/tests/monitor-recovery.test.ts
+++ b/tests/monitor-recovery.test.ts
@@ -667,6 +667,93 @@ test("a check keeps the baseline from a run that finishes during the request", a
assert.equal(task?.state.lastHash, afterRun);
});
+test("resuming from Activity cannot let a worker claim the task before its monitor is active", async () => {
+ const monitor = await createMonitor("Activity resume with worker");
+ await server.agent.worker.tick();
+ await read(`/tasks/${monitor.taskId}/control`, { action: "pause" });
+
+ const originalCas: CompareAndSwap = db.compareAndSwap.bind(db);
+ let ran = false;
+ db.compareAndSwap = (async (o, kind, id, expected, patch) => {
+ if (!ran && kind === "monitors" && id === monitor.id && patch.status === "active") {
+ ran = true;
+ // A separate worker can run between the request's two record updates.
+ await server.agent.worker.tick();
+ }
+ return originalCas(o, kind, id, expected, patch);
+ }) as CompareAndSwap;
+ try {
+ await read(`/tasks/${monitor.taskId}/control`, { action: "resume" });
+ } finally {
+ db.compareAndSwap = originalCas;
+ }
+ assert.ok(ran);
+ await maintain();
+ await server.agent.worker.tick();
+ assert.equal((await db.get<Monitor>(owner, "monitors", monitor.id))?.status, "active");
+ assert.equal((await db.get<AgentTask>(owner, "tasks", monitor.taskId))?.status, "scheduled");
+});
+
+test("maintenance finishes an Activity resume interrupted after activating its monitor", async () => {
+ const monitor = await createMonitor("Interrupted Activity resume");
+ await server.agent.worker.tick();
+ await read(`/tasks/${monitor.taskId}/control`, { action: "pause" });
+
+ const originalCas: CompareAndSwap = db.compareAndSwap.bind(db);
+ let interrupted = false;
+ db.compareAndSwap = (async (o, kind, id, expected, patch) => {
+ const saved = await originalCas(o, kind, id, expected, patch);
+ if (
+ !interrupted &&
+ saved &&
+ kind === "monitors" &&
+ id === monitor.id &&
+ patch.status === "active"
+ ) {
+ interrupted = true;
+ throw new Error("Simulated interruption after activating the monitor");
+ }
+ return saved;
+ }) as CompareAndSwap;
+ try {
+ const response = await request(`/tasks/${monitor.taskId}/control`, { action: "resume" });
+ assert.equal(response.status, 502);
+ } finally {
+ db.compareAndSwap = originalCas;
+ }
+ assert.ok(interrupted);
+ await maintain();
+ await server.agent.worker.tick();
+ assert.equal((await db.get<Monitor>(owner, "monitors", monitor.id))?.status, "active");
+ assert.equal((await db.get<AgentTask>(owner, "tasks", monitor.taskId))?.status, "scheduled");
+});
+
+test("a stop during an Activity resume cannot be undone by that resume", async () => {
+ const monitor = await createMonitor("Stop during Activity resume");
+ await server.agent.worker.tick();
+ await read(`/tasks/${monitor.taskId}/control`, { action: "pause" });
+
+ const originalCas: CompareAndSwap = db.compareAndSwap.bind(db);
+ let stopping: Response | undefined;
+ db.compareAndSwap = (async (o, kind, id, expected, patch) => {
+ if (!stopping && kind === "monitors" && id === monitor.id && patch.status === "active") {
+ db.compareAndSwap = originalCas;
+ stopping = await request(`/monitors/${monitor.id}/control`, { action: "stop" });
+ }
+ return originalCas(o, kind, id, expected, patch);
+ }) as CompareAndSwap;
+ let response: Response;
+ try {
+ response = await request(`/tasks/${monitor.taskId}/control`, { action: "resume" });
+ } finally {
+ db.compareAndSwap = originalCas;
+ }
+ assert.equal(stopping?.status, 200);
+ assert.equal(response.status, 409);
+ assert.equal((await db.get<Monitor>(owner, "monitors", monitor.id))?.status, "stopped");
+ assert.equal((await db.get<AgentTask>(owner, "tasks", monitor.taskId))?.status, "cancelled");
+});
+
test("a second observe from a stale snapshot loses its monitor commit instead of clobbering it", async () => {
await read("/sample-page", { text: "No tables available" });
const monitor = await createMonitor("Stale observe");