@clinebot/core 0.0.35 → 0.0.37

package/src/cron/cron-watcher.ts

@@ -0,0 +1,102 @@
+import type { FSWatcher } from "node:fs";
+import { existsSync, mkdirSync, watch } from "node:fs";
+import { relative, resolve } from "node:path";
+import type { CronReconciler } from "./cron-reconciler";
+
+/**
+ * Filesystem watcher for the configured cron specs directory.
+ *
+ * Uses `node:fs` `watch` with `{ recursive: true }`. Emits a re-reconcile
+ * request for each change, debounced per path, so rapid save bursts from
+ * editors don't cause redundant DB churn.
+ */
+
+const DEFAULT_DEBOUNCE_MS = 250;
+
+export interface CronWatcherOptions {
+	reconciler: CronReconciler;
+	debounceMs?: number;
+	onError?: (error: unknown) => void;
+	onReconciled?: () => void | Promise<void>;
+}
+
+export class CronWatcher {
+	private readonly reconciler: CronReconciler;
+	private readonly debounceMs: number;
+	private readonly onError: (error: unknown) => void;
+	private readonly onReconciled: () => void | Promise<void>;
+	private watcher?: FSWatcher;
+	private readonly pending = new Map<string, ReturnType<typeof setTimeout>>();
+	private disposed = false;
+
+	constructor(options: CronWatcherOptions) {
+		this.reconciler = options.reconciler;
+		this.debounceMs = Math.max(0, options.debounceMs ?? DEFAULT_DEBOUNCE_MS);
+		this.onError = options.onError ?? (() => {});
+		this.onReconciled = options.onReconciled ?? (() => {});
+	}
+
+	public start(): void {
+		if (this.disposed) throw new Error("CronWatcher disposed");
+		if (this.watcher) return;
+		const dir = this.reconciler.getCronDir();
+		try {
+			mkdirSync(dir, { recursive: true });
+			this.watcher = watch(dir, { recursive: true }, (_eventType, filename) => {
+				if (!filename) return;
+				const rel = String(filename).replace(/\\/g, "/");
+				if (!rel.endsWith(".md")) return;
+				if (rel.startsWith("reports/")) return;
+				this.scheduleReconcile(rel);
+			});
+			this.watcher.on("error", this.onError);
+		} catch (err) {
+			this.onError(err);
+		}
+	}
+
+	public stop(): void {
+		for (const timer of this.pending.values()) clearTimeout(timer);
+		this.pending.clear();
+		this.watcher?.close();
+		this.watcher = undefined;
+	}
+
+	public dispose(): void {
+		this.disposed = true;
+		this.stop();
+	}
+
+	private scheduleReconcile(relativePath: string): void {
+		const existing = this.pending.get(relativePath);
+		if (existing) clearTimeout(existing);
+		const timer = setTimeout(() => {
+			this.pending.delete(relativePath);
+			void this.reconcileNow(relativePath);
+		}, this.debounceMs);
+		this.pending.set(relativePath, timer);
+	}
+
+	private async reconcileNow(relativePath: string): Promise<void> {
+		try {
+			const abs = resolve(this.reconciler.getCronDir(), relativePath);
+			if (!existsSync(abs)) {
+				// File was deleted — force a full reconcile to catch the
+				// missing source and mark the spec removed.
+				await this.reconciler.reconcileAll();
+				await this.onReconciled();
+				return;
+			}
+			// Normalize relative path through the reconciler dir to defend
+			// against a watcher emitting an unexpected format.
+			const normalizedRel = relative(this.reconciler.getCronDir(), abs).replace(
+				/\\/g,
+				"/",
+			);
+			await this.reconciler.reconcileFile(normalizedRel, abs);
+			await this.onReconciled();
+		} catch (err) {
+			this.onError(err);
+		}
+	}
+}

package/src/cron/index.ts

@@ -0,0 +1,15 @@
+export * from "./cron-event-ingress";
+export * from "./cron-materializer";
+export * from "./cron-reconciler";
+export * from "./cron-report-writer";
+export * from "./cron-runner";
+export * from "./cron-schema";
+export * from "./cron-service";
+export * from "./cron-spec-parser";
+export * from "./cron-watcher";
+export * from "./resource-limiter";
+export * from "./schedule-command-service";
+export * from "./schedule-service";
+export * from "./scheduler";
+export * from "./sqlite-cron-store";
+export * from "./sqlite-schedule-store";

package/src/cron/resource-limiter.ts

@@ -0,0 +1,46 @@
+export class ResourceLimiter {
+	private readonly globalMaxConcurrency: number;
+	private readonly activeExecutions = new Map<string, Set<string>>();
+
+	constructor(globalMaxConcurrency: number) {
+		this.globalMaxConcurrency = Math.max(1, Math.floor(globalMaxConcurrency));
+	}
+
+	public acquire(
+		scheduleId: string,
+		executionId: string,
+		maxParallel: number,
+	): boolean {
+		if (this.getGlobalActiveCount() >= this.globalMaxConcurrency) {
+			return false;
+		}
+		const perScheduleLimit = Math.max(1, Math.floor(maxParallel));
+		const scheduleExecutions =
+			this.activeExecutions.get(scheduleId) ?? new Set<string>();
+		if (scheduleExecutions.size >= perScheduleLimit) {
+			return false;
+		}
+		scheduleExecutions.add(executionId);
+		this.activeExecutions.set(scheduleId, scheduleExecutions);
+		return true;
+	}
+
+	public release(scheduleId: string, executionId: string): void {
+		const executions = this.activeExecutions.get(scheduleId);
+		if (!executions) {
+			return;
+		}
+		executions.delete(executionId);
+		if (executions.size === 0) {
+			this.activeExecutions.delete(scheduleId);
+		}
+	}
+
+	public getGlobalActiveCount(): number {
+		let total = 0;
+		for (const executions of this.activeExecutions.values()) {
+			total += executions.size;
+		}
+		return total;
+	}
+}

package/src/cron/schedule-command-service.ts

@@ -0,0 +1,193 @@
+import type {
+	HubCommandEnvelope,
+	HubReplyEnvelope,
+	HubScheduleCreateInput,
+	HubScheduleUpdateInput,
+} from "@clinebot/shared";
+import { createSessionId } from "@clinebot/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: 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,
+		};
+	}
+}