codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/cron/service/schedule-command-service.ts

@@ -0,0 +1,198 @@
+import type {
+	HubCommandEnvelope,
+	HubReplyEnvelope,
+	HubScheduleCreateInput,
+	HubScheduleUpdateInput,
+} from "@cline/shared";
+import { createSessionId } from "@cline/shared";
+import type { HubScheduleService } from "./schedule-service";
+
+function okReply(
+	envelope: HubCommandEnvelope,
+	payload?: Record<string, unknown>,
+): HubReplyEnvelope {
+	return {
+		version: envelope.version,
+		requestId: envelope.requestId,
+		ok: true,
+		payload,
+	};
+}
+
+function errorReply(
+	envelope: HubCommandEnvelope,
+	code: string,
+	message: string,
+): HubReplyEnvelope {
+	return {
+		version: envelope.version,
+		requestId: envelope.requestId ?? createSessionId("hubreq_"),
+		ok: false,
+		error: { code, message },
+	};
+}
+
+export class HubScheduleCommandService {
+	constructor(private readonly schedules: HubScheduleService) {}
+
+	public async handleCommand(
+		envelope: HubCommandEnvelope,
+	): Promise<HubReplyEnvelope> {
+		try {
+			switch (envelope.command) {
+				case "schedule.create":
+					return okReply(envelope, {
+						schedule: this.schedules.createSchedule(
+							this.toCreateInput(envelope.payload ?? {}),
+						),
+					});
+				case "schedule.list":
+					return okReply(envelope, {
+						schedules: this.schedules.listSchedules({
+							enabled:
+								typeof envelope.payload?.enabled === "boolean"
+									? envelope.payload.enabled
+									: undefined,
+							limit:
+								typeof envelope.payload?.limit === "number"
+									? envelope.payload.limit
+									: undefined,
+							tags: Array.isArray(envelope.payload?.tags)
+								? (envelope.payload?.tags as string[])
+								: undefined,
+						}),
+					});
+				case "schedule.get":
+					return okReply(envelope, {
+						schedule: this.schedules.getSchedule(
+							String(envelope.payload?.scheduleId ?? ""),
+						),
+					});
+				case "schedule.update":
+					return okReply(envelope, {
+						schedule: this.schedules.updateSchedule(
+							String(envelope.payload?.scheduleId ?? ""),
+							this.toUpdateInput(envelope.payload ?? {}),
+						),
+					});
+				case "schedule.delete":
+					return okReply(envelope, {
+						deleted: this.schedules.deleteSchedule(
+							String(envelope.payload?.scheduleId ?? ""),
+						),
+					});
+				case "schedule.enable":
+					return okReply(envelope, {
+						schedule: this.schedules.resumeSchedule(
+							String(envelope.payload?.scheduleId ?? ""),
+						),
+					});
+				case "schedule.disable":
+					return okReply(envelope, {
+						schedule: this.schedules.pauseSchedule(
+							String(envelope.payload?.scheduleId ?? ""),
+						),
+					});
+				case "schedule.trigger":
+					return okReply(envelope, {
+						execution:
+							envelope.payload?.wait === false
+								? this.schedules.triggerScheduleNowDetached(
+										String(envelope.payload?.scheduleId ?? ""),
+									)
+								: await this.schedules.triggerScheduleNow(
+										String(envelope.payload?.scheduleId ?? ""),
+									),
+					});
+				case "schedule.list_executions":
+					return okReply(envelope, {
+						executions: this.schedules.listScheduleExecutions({
+							scheduleId:
+								typeof envelope.payload?.scheduleId === "string"
+									? envelope.payload.scheduleId
+									: undefined,
+							status:
+								typeof envelope.payload?.status === "string"
+									? (envelope.payload.status as never)
+									: undefined,
+							limit:
+								typeof envelope.payload?.limit === "number"
+									? envelope.payload.limit
+									: undefined,
+						}),
+					});
+				case "schedule.stats":
+					return okReply(envelope, {
+						stats: this.schedules.getScheduleStats(
+							String(envelope.payload?.scheduleId ?? ""),
+						),
+					});
+				case "schedule.active":
+					return okReply(envelope, {
+						executions: this.schedules.getActiveExecutions(),
+					});
+				case "schedule.upcoming":
+					return okReply(envelope, {
+						runs: this.schedules.getUpcomingRuns(
+							typeof envelope.payload?.limit === "number"
+								? envelope.payload.limit
+								: undefined,
+						),
+					});
+				default:
+					return errorReply(
+						envelope,
+						"unsupported_command",
+						`Unsupported hub schedule command: ${envelope.command}`,
+					);
+			}
+		} catch (error) {
+			return errorReply(
+				envelope,
+				"schedule_command_failed",
+				error instanceof Error ? error.message : String(error),
+			);
+		}
+	}
+
+	private toCreateInput(
+		payload: Record<string, unknown>,
+	): HubScheduleCreateInput {
+		const modelSelection =
+			payload.modelSelection &&
+			typeof payload.modelSelection === "object" &&
+			!Array.isArray(payload.modelSelection)
+				? (payload.modelSelection as HubScheduleCreateInput["modelSelection"])
+				: payload.provider && payload.model
+					? {
+							providerId: String(payload.provider),
+							modelId: String(payload.model),
+						}
+					: undefined;
+		return {
+			...(payload as unknown as HubScheduleCreateInput),
+			modelSelection,
+		};
+	}
+
+	private toUpdateInput(
+		payload: Record<string, unknown>,
+	): HubScheduleUpdateInput {
+		const modelSelection =
+			payload.modelSelection &&
+			typeof payload.modelSelection === "object" &&
+			!Array.isArray(payload.modelSelection)
+				? (payload.modelSelection as HubScheduleUpdateInput["modelSelection"])
+				: payload.provider || payload.model
+					? {
+							providerId:
+								typeof payload.provider === "string" ? payload.provider : "",
+							modelId: typeof payload.model === "string" ? payload.model : "",
+						}
+					: undefined;
+		return {
+			...(payload as unknown as HubScheduleUpdateInput),
+			modelSelection,
+		};
+	}
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/cron/service/schedule-service.test.ts

@@ -0,0 +1,213 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { HubScheduleCommandService } from "./schedule-command-service";
+import { HubScheduleService } from "./schedule-service";
+
+const require = createRequire(import.meta.url);
+const sqliteAvailable = (() => {
+	try {
+		require("node:sqlite");
+		return true;
+	} catch {
+		return false;
+	}
+})();
+
+async function createTempDbPath(): Promise<string> {
+	const directory = await mkdtemp(join(tmpdir(), "sdk-hub-schedule-"));
+	return join(directory, "cron.db");
+}
+
+const cleanupPaths: string[] = [];
+
+afterEach(async () => {
+	await Promise.all(
+		cleanupPaths.splice(0).map(async (dbPath) => {
+			await rm(dirname(dbPath), { recursive: true, force: true });
+		}),
+	);
+});
+
+describe("HubScheduleService", () => {
+	const sqliteIt = sqliteAvailable ? it : it.skip;
+
+	sqliteIt("creates, triggers, and reports schedule history", async () => {
+		const dbPath = await createTempDbPath();
+		cleanupPaths.push(dbPath);
+		const publishedEvents: Array<{
+			eventType: string;
+			payload: Record<string, unknown>;
+		}> = [];
+		const service = new HubScheduleService({
+			dbPath,
+			runtimeHandlers: {
+				startSession: vi.fn(async () => ({ sessionId: "session-1" })),
+				sendSession: vi.fn(async () => ({
+					result: {
+						text: "done",
+						iterations: 3,
+						inputTokens: 10,
+						outputTokens: 20,
+						usage: { totalCost: 1.25 },
+					},
+				})),
+				abortSession: vi.fn(async () => ({ applied: true })),
+				stopSession: vi.fn(async () => ({ applied: true })),
+			},
+			eventPublisher: (eventType, payload) => {
+				publishedEvents.push({ eventType, payload });
+			},
+		});
+		try {
+			const created = service.createSchedule({
+				name: "Routine",
+				cronPattern: "0 * * * *",
+				prompt: "Run the routine",
+				workspaceRoot: "/workspace",
+				cwd: "/workspace",
+				modelSelection: {
+					providerId: "openai",
+					modelId: "gpt-5.3-codex",
+				},
+				maxParallel: 1,
+				timeoutSeconds: 30,
+				metadata: { delivery: { threadId: "thread-1" } },
+			});
+
+			const execution = await service.triggerScheduleNow(created.scheduleId);
+			expect(execution?.status).toBe("success");
+			expect(execution?.sessionId).toBe("session-1");
+			expect(publishedEvents).toEqual([
+				{
+					eventType: "schedule.execution.completed",
+					payload: expect.objectContaining({
+						scheduleId: created.scheduleId,
+						executionId: execution?.executionId,
+						sessionId: "session-1",
+						status: "success",
+					}),
+				},
+			]);
+
+			const schedule = service.getSchedule(created.scheduleId);
+			expect(schedule?.metadata).toEqual({
+				delivery: { threadId: "thread-1" },
+			});
+			expect(
+				service.listScheduleExecutions({ scheduleId: created.scheduleId }),
+			).toHaveLength(1);
+			expect(service.getScheduleStats(created.scheduleId).totalRuns).toBe(1);
+			expect(service.getUpcomingRuns(10)).toHaveLength(1);
+		} finally {
+			await service.dispose();
+		}
+	});
+
+	sqliteIt("publishes failed schedule execution events", async () => {
+		const dbPath = await createTempDbPath();
+		cleanupPaths.push(dbPath);
+		const publishedEvents: Array<{
+			eventType: string;
+			payload: Record<string, unknown>;
+		}> = [];
+		const service = new HubScheduleService({
+			dbPath,
+			runtimeHandlers: {
+				startSession: vi.fn(async () => ({ sessionId: "session-failed" })),
+				sendSession: vi.fn(async () => {
+					throw new Error("runtime failed");
+				}),
+				abortSession: vi.fn(async () => ({ applied: true })),
+				stopSession: vi.fn(async () => ({ applied: true })),
+			},
+			eventPublisher: (eventType, payload) => {
+				publishedEvents.push({ eventType, payload });
+			},
+		});
+		try {
+			const created = service.createSchedule({
+				name: "Failure routine",
+				cronPattern: "0 * * * *",
+				prompt: "Run and fail",
+				workspaceRoot: "/workspace",
+				modelSelection: {
+					providerId: "openai",
+					modelId: "gpt-5.3-codex",
+				},
+			});
+
+			const execution = await service.triggerScheduleNow(created.scheduleId);
+			expect(execution?.status).toBe("failed");
+			expect(publishedEvents).toEqual([
+				{
+					eventType: "schedule.execution.failed",
+					payload: expect.objectContaining({
+						scheduleId: created.scheduleId,
+						executionId: execution?.executionId,
+						sessionId: "session-failed",
+						status: "failed",
+						errorMessage: "runtime failed",
+					}),
+				},
+			]);
+		} finally {
+			await service.dispose();
+		}
+	});
+
+	sqliteIt(
+		"handles schedule commands through the hub command adapter",
+		async () => {
+			const dbPath = await createTempDbPath();
+			cleanupPaths.push(dbPath);
+			const service = new HubScheduleService({
+				dbPath,
+				runtimeHandlers: {
+					startSession: vi.fn(async () => ({ sessionId: "session-2" })),
+					sendSession: vi.fn(async () => ({ result: { text: "done" } })),
+					abortSession: vi.fn(async () => ({ applied: true })),
+					stopSession: vi.fn(async () => ({ applied: true })),
+				},
+			});
+			try {
+				const commands = new HubScheduleCommandService(service);
+
+				const createdReply = await commands.handleCommand({
+					version: "v1",
+					command: "schedule.create",
+					payload: {
+						name: "Command routine",
+						cronPattern: "15 * * * *",
+						prompt: "Run from command",
+						workspaceRoot: "/workspace",
+						modelSelection: {
+							providerId: "openai",
+							modelId: "gpt-5.3-codex",
+						},
+					},
+				});
+				expect(createdReply.ok).toBe(true);
+				const created = createdReply.payload?.schedule as {
+					scheduleId: string;
+				};
+
+				const listReply = await commands.handleCommand({
+					version: "v1",
+					command: "schedule.list",
+					payload: { limit: 10 },
+				});
+				expect(listReply.ok).toBe(true);
+				expect(
+					(listReply.payload?.schedules as Array<{ scheduleId: string }>).some(
+						(item) => item.scheduleId === created.scheduleId,
+					),
+				).toBe(true);
+			} finally {
+				await service.dispose();
+			}
+		},
+	);
+});