@mulmoclaude/core 0.1.0

package/dist/notifier/store.d.ts

@@ -0,0 +1,18 @@
+import { NotifierFile, NotifierHistoryFile } from './types.js';
+/** Injected atomic JSON writer — the host's `writeJsonAtomic`. */
+export type WriteJson = (filePath: string, data: unknown) => Promise<void>;
+/** Read the active-entries file. Returns an empty store when the file
+ *  doesn't exist yet (first ever call on a fresh workspace). Any other
+ *  read or parse failure throws — the caller has to decide whether to
+ *  surface or recover, since silently treating "malformed file" as
+ *  "no entries" would lose data. */
+export declare function loadActive(filePath: string): Promise<NotifierFile>;
+/** Write the active-entries file via the injected atomic writer so a
+ *  half-written file is never visible to readers. The caller serialises
+ *  writes (engine.ts queues mutations) — this function makes no
+ *  concurrency guarantees of its own. */
+export declare function saveActive(writeJson: WriteJson, filePath: string, state: NotifierFile): Promise<void>;
+/** Read the history file. Empty array on first run. Same parse-error
+ *  policy as `loadActive`. */
+export declare function loadHistory(filePath: string): Promise<NotifierHistoryFile>;
+export declare function saveHistory(writeJson: WriteJson, filePath: string, state: NotifierHistoryFile): Promise<void>;

package/dist/notifier/types.d.ts

@@ -0,0 +1,118 @@
+/** Two notification shapes, distinguished by who fires the close call:
+ *
+ *    `fyi`    — informational. The host (bell panel) clears it when the
+ *               user dismisses the row. No deep-link target.
+ *    `action` — pending obligation. The plugin clears it when the
+ *               underlying domain state changes (the user paid the tax,
+ *               viewed the digest, etc.). The bell row navigates to
+ *               `navigateTarget` on click.
+ *
+ *  The engine reads `lifecycle` only to enforce two publish-time rules
+ *  (everything downstream — pubsub fan-out, persistence, history — is
+ *  lifecycle-blind):
+ *
+ *    1. `action` requires a non-empty `navigateTarget`. Without one,
+ *       clicking the row does nothing and the entry is a degraded fyi.
+ *    2. `action` cannot use `info` severity. A low-priority obligation
+ *       is incoherent — fyi if it's a ping, `nudge`/`urgent` if it's a
+ *       real obligation worth a landing page.
+ *
+ *  Both rules are mirrored in the HTTP layer so plugin-runtime callers
+ *  and HTTP callers hit the same wall. */
+export declare const NOTIFIER_LIFECYCLES: readonly ["fyi", "action"];
+export type NotifierLifecycle = (typeof NOTIFIER_LIFECYCLES)[number];
+/** Severity drives badge color (gray / amber / red, worst-wins) and
+ *  in a future iteration channel routing. Mostly stored verbatim by
+ *  the engine; the one engine-visible interaction is the rule that
+ *  `action` lifecycle cannot pair with `info` severity (see
+ *  `NotifierLifecycle` above). */
+export declare const NOTIFIER_SEVERITIES: readonly ["info", "nudge", "urgent"];
+export type NotifierSeverity = (typeof NOTIFIER_SEVERITIES)[number];
+export interface NotifierEntry<TPluginData = unknown> {
+    /** Engine-assigned UUID. Generated synchronously inside `publish()`
+     *  so the caller can use it before persistence completes. */
+    id: string;
+    /** Plugin namespace (e.g. `"encore"`, `"debug__system"`). The
+     *  engine never inspects it — used only for `listFor()` filtering
+     *  and as a UI grouping key. */
+    pluginPkg: string;
+    severity: NotifierSeverity;
+    lifecycle?: NotifierLifecycle;
+    title: string;
+    body?: string;
+    /** Optional in-app deep-link target (relative URL). The bell popup
+     *  routes here on row click, with `&notificationId=<id>` appended
+     *  so the landing page can identify which entry to clear. The
+     *  engine doesn't read this — it's a UI hint stored on the entry. */
+    navigateTarget?: string;
+    /** Opaque to the engine. Round-trips through JSON unchanged; only
+     *  the originating plugin's UI knows the shape. */
+    pluginData?: TPluginData;
+    /** ISO-8601 timestamp set at `publish()` time. */
+    createdAt: string;
+}
+/** A history entry — a `NotifierEntry` after it has been cleared or
+ *  cancelled, with the terminal type and timestamp recorded. The
+ *  bell popup's "History" section renders these read-only. */
+export interface NotifierHistoryEntry<TPluginData = unknown> extends NotifierEntry<TPluginData> {
+    terminalType: "cleared" | "cancelled";
+    terminalAt: string;
+}
+/** Caller-supplied input for `publish()`. The engine fills in `id`
+ *  and `createdAt`; everything else flows through verbatim.
+ *
+ *  Two publish-time rules apply to `action` lifecycle (see
+ *  `NotifierLifecycle`):
+ *
+ *    - `navigateTarget` MUST be a non-empty string.
+ *    - `severity` MUST NOT be `"info"`.
+ *
+ *  Violations cause `publish()` to throw. Currently expressed as
+ *  runtime validation rather than a discriminated-union type, so the
+ *  fields below are all individually optional / loose at the
+ *  type-level. */
+export interface PublishInput<TPluginData = unknown> {
+    pluginPkg: string;
+    severity: NotifierSeverity;
+    title: string;
+    body?: string;
+    lifecycle?: NotifierLifecycle;
+    navigateTarget?: string;
+    pluginData?: TPluginData;
+}
+/** On-disk shape of `~/mulmoclaude/data/notifier/active.json`. Holds
+ *  only entries that haven't been cleared or cancelled — the file is
+ *  a snapshot, not an event log. */
+export interface NotifierFile {
+    entries: Record<string, NotifierEntry>;
+}
+/** On-disk shape of `~/mulmoclaude/data/notifier/history.json`. Array
+ *  of terminated entries newest-first, capped at `HISTORY_CAP` with
+ *  FIFO eviction (push at index 0, slice from the tail). */
+export interface NotifierHistoryFile {
+    entries: NotifierHistoryEntry[];
+}
+/** History size cap. The bell popup's History section renders this
+ *  many entries; older ones fall off when new terminations land. */
+export declare const HISTORY_CAP = 50;
+/** Pub-sub event published on the host's notifier channel after every
+ *  successful state change. Discriminated union — subscribers switch
+ *  on `type` to keep TypeScript narrowing the rest of the payload.
+ *
+ *  `updated` carries the post-mutation entry — the receiver swaps
+ *  the matching `id` in their local active set. Reserved for in-
+ *  place edits via `updateForPlugin`; no history record is written
+ *  because the entry is still active, just with refreshed content. */
+export type NotifierEvent = {
+    type: "published";
+    entry: NotifierEntry;
+} | {
+    type: "cleared";
+    id: string;
+} | {
+    type: "cancelled";
+    id: string;
+} | {
+    type: "updated";
+    entry: NotifierEntry;
+};

package/dist/notifier/validate.d.ts

@@ -0,0 +1,17 @@
+import { PublishInput } from './types.js';
+/** Hard caps on publish-input fields. The engine reads each entry on
+ *  every list/get call (no in-memory cache), so unbounded fields hurt
+ *  every reader. Caps chosen to be generous for legitimate UX copy
+ *  while bounding active.json growth: a notification fundamentally is
+ *  a short blurb, not a document. */
+export declare const NOTIFIER_LIMITS: {
+    readonly titleMax: 200;
+    readonly bodyMax: 4000;
+    readonly navigateTargetMax: 1000;
+    readonly pluginDataMaxBytes: number;
+};
+/** Validate a `PublishInput`. Returns `null` if OK, or a
+ *  human-readable error string. Order matters — shape/size errors are
+ *  reported before lifecycle/severity coherence errors so the message
+ *  the caller sees points at the most fundamental problem first. */
+export declare function validatePublishInput(input: PublishInput): string | null;

package/dist/scheduler/adapter.d.ts

@@ -0,0 +1,48 @@
+import { TaskExecutionState, TaskLogEntry, MISSED_RUN_POLICIES } from '@receptron/task-scheduler';
+import { ITaskManager, TaskDefinition, SchedulerLogger } from './task-manager.js';
+export interface SchedulerConfig {
+    /** Absolute workspace root — state.json + logs hang off it. */
+    workspaceRoot: string;
+    /** Host atomic file writer (used with `uniqueTmp` for the state file). */
+    writeFileAtomic: (filePath: string, content: string, opts: {
+        uniqueTmp: boolean;
+    }) => Promise<void>;
+    /** Optional logger. */
+    log?: SchedulerLogger;
+}
+/** Wire the adapter to a host. Call once at startup, before `initScheduler`. */
+export declare function configureScheduler(injected: SchedulerConfig): void;
+export interface SystemTaskDef {
+    id: string;
+    name: string;
+    description: string;
+    schedule: TaskDefinition["schedule"];
+    missedRunPolicy: typeof MISSED_RUN_POLICIES.skip | typeof MISSED_RUN_POLICIES.runOnce | typeof MISSED_RUN_POLICIES.runAll;
+    run: () => Promise<void>;
+}
+/**
+ * Initialize the scheduler adapter. Call once at server startup AFTER the
+ * task-manager is created but BEFORE `taskManager.start()`.
+ */
+export declare function initScheduler(taskManager: ITaskManager, tasks: SystemTaskDef[]): Promise<void>;
+/** Apply a schedule override to a running system task. Updates the
+ *  in-memory task definition, the task-manager, and recalculates
+ *  nextScheduledAt in persisted state. */
+export declare function applyScheduleOverride(taskId: string, schedule: SystemTaskDef["schedule"]): Promise<boolean>;
+/** Query execution logs — used by API routes. */
+export declare function getSchedulerLogs(opts: {
+    since?: string;
+    taskId?: string;
+    limit?: number;
+}): Promise<TaskLogEntry[]>;
+/** Get all task states — used by API routes. */
+export declare function getSchedulerTasks(): {
+    id: string;
+    name: string;
+    description: string;
+    schedule: TaskDefinition["schedule"];
+    missedRunPolicy: string;
+    state: TaskExecutionState;
+}[];
+/** Test-only: clear config + in-memory state. */
+export declare function resetSchedulerForTesting(): void;

package/dist/scheduler/index.cjs

@@ -0,0 +1,352 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("../chunk-CKQMccvm.cjs");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path, 1);
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+let _receptron_task_scheduler = require("@receptron/task-scheduler");
+//#region src/scheduler/task-manager.ts
+var ONE_SECOND_MS$1 = 1e3;
+var ONE_MINUTE_MS = 60 * ONE_SECOND_MS$1;
+var ONE_HOUR_MS = 60 * ONE_MINUTE_MS;
+var NOOP_LOG$1 = {
+	info: () => {},
+	warn: () => {},
+	error: () => {}
+};
+function isDue(now, schedule, tickMs) {
+	if (schedule.type === _receptron_task_scheduler.SCHEDULE_TYPES.interval) {
+		const msSinceMidnight = now.getUTCHours() * ONE_HOUR_MS + now.getUTCMinutes() * ONE_MINUTE_MS + now.getUTCSeconds() * ONE_SECOND_MS$1;
+		return Math.floor(msSinceMidnight / tickMs) * tickMs % schedule.intervalMs === 0;
+	}
+	if (schedule.type === _receptron_task_scheduler.SCHEDULE_TYPES.daily) {
+		const [hours, minutes] = schedule.time.split(":").map(Number);
+		const targetMs = hours * ONE_HOUR_MS + minutes * ONE_MINUTE_MS;
+		const msSinceMidnight = now.getUTCHours() * ONE_HOUR_MS + now.getUTCMinutes() * ONE_MINUTE_MS + now.getUTCSeconds() * ONE_SECOND_MS$1;
+		return Math.floor(msSinceMidnight / tickMs) * tickMs === targetMs;
+	}
+	return false;
+}
+function createTaskManager(options) {
+	const tickMs = options?.tickMs ?? ONE_MINUTE_MS;
+	const now = options?.now ?? (() => /* @__PURE__ */ new Date());
+	const log = options?.log ?? NOOP_LOG$1;
+	const registry = /* @__PURE__ */ new Map();
+	let timer = null;
+	function collectDueTasks(currentTime) {
+		const independent = [];
+		const dependent = [];
+		for (const def of registry.values()) {
+			if (def.enabled === false) continue;
+			if (!isDue(currentTime, def.schedule, tickMs)) continue;
+			if (def.dependsOn) dependent.push(def);
+			else independent.push(def);
+		}
+		return {
+			independent,
+			dependent
+		};
+	}
+	async function runAndTrack(def, currentTime, succeeded) {
+		try {
+			await def.run({
+				taskId: def.id,
+				now: currentTime
+			});
+			succeeded.add(def.id);
+		} catch (err) {
+			log.error("task failed", {
+				id: def.id,
+				error: String(err)
+			});
+		}
+	}
+	async function runDependentChain(dependent, currentTime, succeeded) {
+		let remaining = [...dependent];
+		let progress = true;
+		while (remaining.length > 0 && progress) {
+			progress = false;
+			const next = [];
+			for (const def of remaining) {
+				const dep = def.dependsOn;
+				if (!dep || !succeeded.has(dep)) {
+					next.push(def);
+					continue;
+				}
+				await runAndTrack(def, currentTime, succeeded);
+				progress = true;
+			}
+			remaining = next;
+		}
+	}
+	async function onTick() {
+		const currentTime = now();
+		const { independent, dependent } = collectDueTasks(currentTime);
+		const succeeded = /* @__PURE__ */ new Set();
+		await Promise.all(independent.map((def) => runAndTrack(def, currentTime, succeeded)));
+		await runDependentChain(dependent, currentTime, succeeded);
+	}
+	return {
+		async tick() {
+			await onTick();
+		},
+		registerTask(def) {
+			if (registry.has(def.id)) throw new Error(`[task-manager] Task "${def.id}" is already registered`);
+			registry.set(def.id, def);
+			log.info("registered", { id: def.id });
+		},
+		updateSchedule(taskId, schedule) {
+			const def = registry.get(taskId);
+			if (!def) return false;
+			def.schedule = schedule;
+			log.info("schedule updated", { id: taskId });
+			return true;
+		},
+		removeTask(taskId) {
+			if (registry.delete(taskId)) log.info("removed", { id: taskId });
+		},
+		start() {
+			if (timer) return;
+			timer = setInterval(onTick, tickMs);
+			log.info("started", { tickMs });
+		},
+		stop() {
+			if (timer) {
+				clearInterval(timer);
+				timer = null;
+				log.info("stopped");
+			}
+		},
+		listTasks() {
+			return [...registry.values()].map((taskDef) => ({
+				id: taskDef.id,
+				description: taskDef.description,
+				schedule: taskDef.schedule,
+				dependsOn: taskDef.dependsOn
+			}));
+		}
+	};
+}
+//#endregion
+//#region src/scheduler/adapter.ts
+var ONE_SECOND_MS = 1e3;
+var SCHEDULER_CONFIG_DIR = "config/scheduler";
+var SCHEDULER_DATA_DIR = "data/scheduler/logs";
+var NOOP_LOG = {
+	info: () => {},
+	warn: () => {},
+	error: () => {}
+};
+var config = null;
+/** Wire the adapter to a host. Call once at startup, before `initScheduler`. */
+function configureScheduler(injected) {
+	config = injected;
+}
+function requireConfig() {
+	if (!config) throw new Error("scheduler: configureScheduler() not called");
+	return config;
+}
+function logger() {
+	return config?.log ?? NOOP_LOG;
+}
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+function stateFilePath() {
+	return node_path.default.join(requireConfig().workspaceRoot, SCHEDULER_CONFIG_DIR, "state.json");
+}
+function logsDir() {
+	return node_path.default.join(requireConfig().workspaceRoot, SCHEDULER_DATA_DIR);
+}
+function stateDeps() {
+	return {
+		readFile: (filePath) => (0, node_fs_promises.readFile)(filePath, "utf-8"),
+		writeFileAtomic: (filePath, content) => requireConfig().writeFileAtomic(filePath, content, { uniqueTmp: true }),
+		exists: node_fs.existsSync
+	};
+}
+var logDeps = {
+	appendFile: (filePath, content) => (0, node_fs_promises.appendFile)(filePath, content),
+	readFile: (filePath) => (0, node_fs_promises.readFile)(filePath, "utf-8"),
+	exists: node_fs.existsSync,
+	ensureDir: (directoryPath) => (0, node_fs_promises.mkdir)(directoryPath, { recursive: true }).then(() => {})
+};
+var stateMap = /* @__PURE__ */ new Map();
+var systemTasks = [];
+var taskManagerRef = null;
+/**
+* Initialize the scheduler adapter. Call once at server startup AFTER the
+* task-manager is created but BEFORE `taskManager.start()`.
+*/
+async function initScheduler(taskManager, tasks) {
+	await (0, node_fs_promises.mkdir)(node_path.default.dirname(stateFilePath()), { recursive: true });
+	await (0, node_fs_promises.mkdir)(logsDir(), { recursive: true });
+	stateMap = await (0, _receptron_task_scheduler.loadState)(stateFilePath(), stateDeps());
+	systemTasks.length = 0;
+	systemTasks.push(...tasks);
+	taskManagerRef = taskManager;
+	const plan = (0, _receptron_task_scheduler.computeCatchUpPlan)(tasks.map((taskDef) => ({
+		id: taskDef.id,
+		name: taskDef.name,
+		schedule: toCoreSchedule(taskDef.schedule),
+		missedRunPolicy: taskDef.missedRunPolicy,
+		enabled: true
+	})), stateMap, Date.now());
+	for (const skip of plan.skipped) {
+		logger().info("catch-up skipped", {
+			taskId: skip.taskId,
+			windows: skip.windowCount
+		});
+		await safeUpdateState(skip.taskId, { lastRunAt: skip.lastWindow });
+	}
+	if (plan.runs.length > 0) {
+		logger().info("catch-up enqueued", { runs: plan.runs.length });
+		for (const run of plan.runs) {
+			const task = tasks.find((taskDef) => taskDef.id === run.taskId);
+			if (!task) continue;
+			await executeAndLog(task, run.context.scheduledFor, _receptron_task_scheduler.TASK_TRIGGERS.catchUp);
+		}
+	}
+	for (const task of tasks) taskManager.registerTask({
+		id: task.id,
+		description: task.description,
+		schedule: task.schedule,
+		run: async () => {
+			await executeAndLog(task, computeCurrentWindow(task), _receptron_task_scheduler.TASK_TRIGGERS.scheduled);
+		}
+	});
+	logger().info("initialized", {
+		tasks: tasks.map((taskDef) => taskDef.id),
+		stateEntries: stateMap.size
+	});
+}
+/** Apply a schedule override to a running system task. Updates the
+*  in-memory task definition, the task-manager, and recalculates
+*  nextScheduledAt in persisted state. */
+async function applyScheduleOverride(taskId, schedule) {
+	const task = systemTasks.find((taskDef) => taskDef.id === taskId);
+	if (!task || !taskManagerRef) return false;
+	if (!taskManagerRef.updateSchedule(taskId, schedule)) return false;
+	task.schedule = schedule;
+	await safeUpdateState(taskId, { nextScheduledAt: computeNextScheduled(task) });
+	return true;
+}
+/** Query execution logs — used by API routes. */
+async function getSchedulerLogs(opts) {
+	return (0, _receptron_task_scheduler.queryLog)(logsDir(), opts, logDeps);
+}
+/** Get all task states — used by API routes. */
+function getSchedulerTasks() {
+	return systemTasks.map((taskDef) => ({
+		id: taskDef.id,
+		name: taskDef.name,
+		description: taskDef.description,
+		schedule: taskDef.schedule,
+		missedRunPolicy: taskDef.missedRunPolicy,
+		state: stateMap.get(taskDef.id) ?? (0, _receptron_task_scheduler.emptyState)(taskDef.id)
+	}));
+}
+/** Test-only: clear config + in-memory state. */
+function resetSchedulerForTesting() {
+	config = null;
+	stateMap = /* @__PURE__ */ new Map();
+	systemTasks.length = 0;
+	taskManagerRef = null;
+}
+async function executeAndLog(task, scheduledFor, trigger) {
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const startMs = Date.now();
+	let errMsg = null;
+	try {
+		await task.run();
+	} catch (err) {
+		errMsg = errorMessage(err);
+		logger().error("task failed", {
+			taskId: task.id,
+			error: errMsg
+		});
+	}
+	await safePersist(task, scheduledFor, startedAt, Date.now() - startMs, trigger, errMsg);
+}
+/** Best-effort persistence — state and log are independent. A failure in
+*  one does not block the other, and neither propagates upward. */
+async function safePersist(task, scheduledFor, startedAt, durationMs, trigger, errMsg) {
+	const isSuccess = errMsg === null;
+	const currentState = stateMap.get(task.id);
+	try {
+		await (0, _receptron_task_scheduler.updateAndSave)(stateFilePath(), stateMap, task.id, {
+			lastRunAt: scheduledFor,
+			lastRunResult: isSuccess ? _receptron_task_scheduler.TASK_RESULTS.success : _receptron_task_scheduler.TASK_RESULTS.error,
+			lastRunDurationMs: durationMs,
+			lastErrorMessage: errMsg,
+			consecutiveFailures: isSuccess ? 0 : (currentState?.consecutiveFailures ?? 0) + 1,
+			totalRuns: (currentState?.totalRuns ?? 0) + 1,
+			nextScheduledAt: computeNextScheduled(task)
+		}, stateDeps());
+	} catch (err) {
+		logger().warn("state persistence failed", {
+			taskId: task.id,
+			error: String(err)
+		});
+	}
+	try {
+		await (0, _receptron_task_scheduler.appendLogEntry)(logsDir(), {
+			taskId: task.id,
+			taskName: task.name,
+			scheduledFor,
+			startedAt,
+			completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			result: isSuccess ? _receptron_task_scheduler.TASK_RESULTS.success : _receptron_task_scheduler.TASK_RESULTS.error,
+			durationMs,
+			trigger,
+			...errMsg !== null && { errorMessage: errMsg }
+		}, logDeps);
+	} catch (err) {
+		logger().warn("log persistence failed", {
+			taskId: task.id,
+			error: String(err)
+		});
+	}
+}
+/** Safe state update — swallows errors. */
+async function safeUpdateState(taskId, patch) {
+	try {
+		await (0, _receptron_task_scheduler.updateAndSave)(stateFilePath(), stateMap, taskId, patch, stateDeps());
+	} catch (err) {
+		logger().warn("state update failed", {
+			taskId,
+			error: String(err)
+		});
+	}
+}
+/** Compute the window boundary that the current tick belongs to. For
+*  scheduled runs, this is the epoch-aligned window — not the wall-clock
+*  time of execution. This keeps lastRunAt consistent with catch-up's
+*  window-based accounting. */
+function computeCurrentWindow(task) {
+	const coreSchedule = toCoreSchedule(task.schedule);
+	const nowMs = Date.now();
+	const windowMs = (0, _receptron_task_scheduler.nextWindowAfter)(coreSchedule, nowMs - (coreSchedule.type === _receptron_task_scheduler.SCHEDULE_TYPES.interval ? coreSchedule.intervalSec * ONE_SECOND_MS : 0));
+	return windowMs !== null && windowMs <= nowMs ? new Date(windowMs).toISOString() : new Date(nowMs).toISOString();
+}
+function computeNextScheduled(task) {
+	const next = (0, _receptron_task_scheduler.nextWindowAfter)(toCoreSchedule(task.schedule), Date.now() + 1);
+	return next !== null ? new Date(next).toISOString() : null;
+}
+function toCoreSchedule(schedule) {
+	if (schedule.type === _receptron_task_scheduler.SCHEDULE_TYPES.interval) return {
+		type: _receptron_task_scheduler.SCHEDULE_TYPES.interval,
+		intervalSec: Math.round(schedule.intervalMs / ONE_SECOND_MS)
+	};
+	return schedule;
+}
+//#endregion
+exports.applyScheduleOverride = applyScheduleOverride;
+exports.configureScheduler = configureScheduler;
+exports.createTaskManager = createTaskManager;
+exports.getSchedulerLogs = getSchedulerLogs;
+exports.getSchedulerTasks = getSchedulerTasks;
+exports.initScheduler = initScheduler;
+exports.resetSchedulerForTesting = resetSchedulerForTesting;
+
+//# sourceMappingURL=index.cjs.map

package/dist/scheduler/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/scheduler/task-manager.ts","../../src/scheduler/adapter.ts"],"sourcesContent":["// Generic dependency-ordered cron tick engine. Host-agnostic: the only\n// host coupling (a logger) is injected via options. Schedules are either\n// fixed intervals or a daily UTC time; tasks may declare a `dependsOn`\n// edge so an ordering like \"news fetch → journal → memory extraction\"\n// runs in sequence within one tick.\n\nimport { SCHEDULE_TYPES } from \"@receptron/task-scheduler\";\n\nconst ONE_SECOND_MS = 1000;\nconst ONE_MINUTE_MS = 60 * ONE_SECOND_MS;\nconst ONE_HOUR_MS = 60 * ONE_MINUTE_MS;\n\n/** Minimal logger the engine logs through. Absent one, runs silent. */\nexport interface SchedulerLogger {\n  info: (message: string, data?: Record<string, unknown>) => void;\n  warn: (message: string, data?: Record<string, unknown>) => void;\n  error: (message: string, data?: Record<string, unknown>) => void;\n}\n\nconst NOOP_LOG: SchedulerLogger = { info: () => {}, warn: () => {}, error: () => {} };\n\nexport type TaskSchedule = { type: typeof SCHEDULE_TYPES.interval; intervalMs: number } | { type: typeof SCHEDULE_TYPES.daily; time: string }; // time: \"HH:MM\" in UTC\n\nexport interface TaskRunContext {\n  taskId: string;\n  now: Date;\n}\n\nexport interface TaskDefinition {\n  id: string;\n  description?: string;\n  schedule: TaskSchedule;\n  enabled?: boolean; // default: true\n  /** If set, this task only fires after the named task has completed\n   *  successfully in the current tick cycle. Enforces ordering like\n   *  \"news fetch → journal → memory extraction\". */\n  dependsOn?: string;\n  run: (ctx: TaskRunContext) => Promise<void>;\n}\n\nexport interface ITaskManager {\n  registerTask: (def: TaskDefinition) => void;\n  removeTask: (taskId: string) => void;\n  /** Update the schedule of an existing task. Returns false if not found. */\n  updateSchedule: (taskId: string, schedule: TaskSchedule) => boolean;\n  start: () => void;\n  stop: () => void;\n  /** Run one tick manually (for testing). */\n  tick: () => Promise<void>;\n  listTasks: () => {\n    id: string;\n    description?: string;\n    schedule: TaskSchedule;\n    dependsOn?: string;\n  }[];\n}\n\nexport interface TaskManagerOptions {\n  tickMs?: number; // default: ONE_MINUTE_MS\n  now?: () => Date; // default: () => new Date()\n  log?: SchedulerLogger; // default: noop\n}\n\nfunction isDue(now: Date, schedule: TaskSchedule, tickMs: number): boolean {\n  if (schedule.type === SCHEDULE_TYPES.interval) {\n    const msSinceMidnight = now.getUTCHours() * ONE_HOUR_MS + now.getUTCMinutes() * ONE_MINUTE_MS + now.getUTCSeconds() * ONE_SECOND_MS;\n    // Round down to tick boundary, then check if it aligns with the interval\n    const rounded = Math.floor(msSinceMidnight / tickMs) * tickMs;\n    return rounded % schedule.intervalMs === 0;\n  }\n\n  if (schedule.type === SCHEDULE_TYPES.daily) {\n    const [hours, minutes] = schedule.time.split(\":\").map(Number);\n    const targetMs = hours * ONE_HOUR_MS + minutes * ONE_MINUTE_MS;\n    const msSinceMidnight = now.getUTCHours() * ONE_HOUR_MS + now.getUTCMinutes() * ONE_MINUTE_MS + now.getUTCSeconds() * ONE_SECOND_MS;\n    const rounded = Math.floor(msSinceMidnight / tickMs) * tickMs;\n    return rounded === targetMs;\n  }\n\n  return false;\n}\n\nexport function createTaskManager(options?: TaskManagerOptions): ITaskManager {\n  const tickMs = options?.tickMs ?? ONE_MINUTE_MS;\n  const now = options?.now ?? (() => new Date());\n  const log = options?.log ?? NOOP_LOG;\n  const registry = new Map<string, TaskDefinition>();\n  let timer: ReturnType<typeof setInterval> | null = null;\n\n  function collectDueTasks(currentTime: Date): {\n    independent: TaskDefinition[];\n    dependent: TaskDefinition[];\n  } {\n    const independent: TaskDefinition[] = [];\n    const dependent: TaskDefinition[] = [];\n    for (const def of registry.values()) {\n      if (def.enabled === false) continue;\n      if (!isDue(currentTime, def.schedule, tickMs)) continue;\n      if (def.dependsOn) {\n        dependent.push(def);\n      } else {\n        independent.push(def);\n      }\n    }\n    return { independent, dependent };\n  }\n\n  async function runAndTrack(def: TaskDefinition, currentTime: Date, succeeded: Set<string>): Promise<void> {\n    try {\n      await def.run({ taskId: def.id, now: currentTime });\n      succeeded.add(def.id);\n    } catch (err) {\n      log.error(\"task failed\", {\n        id: def.id,\n        error: String(err),\n      });\n    }\n  }\n\n  async function runDependentChain(dependent: TaskDefinition[], currentTime: Date, succeeded: Set<string>): Promise<void> {\n    let remaining = [...dependent];\n    let progress = true;\n    while (remaining.length > 0 && progress) {\n      progress = false;\n      const next: TaskDefinition[] = [];\n      for (const def of remaining) {\n        const dep = def.dependsOn;\n        if (!dep || !succeeded.has(dep)) {\n          next.push(def);\n          continue;\n        }\n        await runAndTrack(def, currentTime, succeeded);\n        progress = true;\n      }\n      remaining = next;\n    }\n  }\n\n  async function onTick(): Promise<void> {\n    const currentTime = now();\n    const { independent, dependent } = collectDueTasks(currentTime);\n\n    // Per-invocation set — success does not leak across tick() calls.\n    const succeeded = new Set<string>();\n\n    await Promise.all(independent.map((def) => runAndTrack(def, currentTime, succeeded)));\n\n    await runDependentChain(dependent, currentTime, succeeded);\n  }\n\n  return {\n    async tick() {\n      await onTick();\n    },\n\n    registerTask(def: TaskDefinition) {\n      if (registry.has(def.id)) {\n        throw new Error(`[task-manager] Task \"${def.id}\" is already registered`);\n      }\n      registry.set(def.id, def);\n      log.info(\"registered\", { id: def.id });\n    },\n\n    updateSchedule(taskId: string, schedule: TaskSchedule): boolean {\n      const def = registry.get(taskId);\n      if (!def) return false;\n      def.schedule = schedule;\n      log.info(\"schedule updated\", { id: taskId });\n      return true;\n    },\n\n    removeTask(taskId: string) {\n      if (registry.delete(taskId)) {\n        log.info(\"removed\", { id: taskId });\n      }\n    },\n\n    start() {\n      if (timer) return;\n      timer = setInterval(onTick, tickMs);\n      log.info(\"started\", { tickMs });\n    },\n\n    stop() {\n      if (timer) {\n        clearInterval(timer);\n        timer = null;\n        log.info(\"stopped\");\n      }\n    },\n\n    listTasks() {\n      return [...registry.values()].map((taskDef) => ({\n        id: taskDef.id,\n        description: taskDef.description,\n        schedule: taskDef.schedule,\n        dependsOn: taskDef.dependsOn,\n      }));\n    },\n  };\n}\n","// Adapter that wires the pure scheduler library (@receptron/task-scheduler)\n// to a host's task-manager + workspace. Registers system tasks, runs\n// catch-up on startup, and persists execution state + logs.\n//\n// Host-agnostic: the workspace root, the atomic file writer, and the\n// logger are injected via `configureScheduler`. The host supplies its OWN\n// system tasks (journal / feeds / user-cron in MulmoClaude) to\n// `initScheduler` — the package owns no task definitions. Deliberately\n// thin: all complex scheduling logic lives in @receptron/task-scheduler.\n\nimport { existsSync } from \"node:fs\";\nimport { readFile, appendFile, mkdir } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport {\n  type TaskSchedule,\n  type TaskExecutionState,\n  type TaskLogEntry,\n  type CatchUpTask,\n  type TaskTrigger,\n  emptyState,\n  computeCatchUpPlan,\n  nextWindowAfter,\n  loadState,\n  updateAndSave,\n  appendLogEntry,\n  queryLog,\n  SCHEDULE_TYPES,\n  TASK_RESULTS,\n  TASK_TRIGGERS,\n  type MISSED_RUN_POLICIES,\n  type StateMap,\n  type StateDeps,\n  type LogDeps,\n} from \"@receptron/task-scheduler\";\nimport type { ITaskManager, TaskDefinition, SchedulerLogger } from \"./task-manager.js\";\n\nconst ONE_SECOND_MS = 1000;\nconst SCHEDULER_CONFIG_DIR = \"config/scheduler\";\nconst SCHEDULER_DATA_DIR = \"data/scheduler/logs\";\n\n// ── Host injection ────────────────────────────────────────────────\n\nexport interface SchedulerConfig {\n  /** Absolute workspace root — state.json + logs hang off it. */\n  workspaceRoot: string;\n  /** Host atomic file writer (used with `uniqueTmp` for the state file). */\n  writeFileAtomic: (filePath: string, content: string, opts: { uniqueTmp: boolean }) => Promise<void>;\n  /** Optional logger. */\n  log?: SchedulerLogger;\n}\n\nconst NOOP_LOG: SchedulerLogger = { info: () => {}, warn: () => {}, error: () => {} };\n\nlet config: SchedulerConfig | null = null;\n\n/** Wire the adapter to a host. Call once at startup, before `initScheduler`. */\nexport function configureScheduler(injected: SchedulerConfig): void {\n  config = injected;\n}\n\nfunction requireConfig(): SchedulerConfig {\n  if (!config) throw new Error(\"scheduler: configureScheduler() not called\");\n  return config;\n}\n\nfunction logger(): SchedulerLogger {\n  return config?.log ?? NOOP_LOG;\n}\n\nfunction errorMessage(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\n// ── Paths ─────────────────────────────────────────────────────────\n\nfunction stateFilePath(): string {\n  return path.join(requireConfig().workspaceRoot, SCHEDULER_CONFIG_DIR, \"state.json\");\n}\n\nfunction logsDir(): string {\n  return path.join(requireConfig().workspaceRoot, SCHEDULER_DATA_DIR);\n}\n\n// ── I/O deps (real filesystem) ────────────────────────────────────\n\nfunction stateDeps(): StateDeps {\n  return {\n    readFile: (filePath: string) => readFile(filePath, \"utf-8\"),\n    writeFileAtomic: (filePath: string, content: string) => requireConfig().writeFileAtomic(filePath, content, { uniqueTmp: true }),\n    exists: existsSync,\n  };\n}\n\nconst logDeps: LogDeps = {\n  appendFile: (filePath: string, content: string) => appendFile(filePath, content),\n  readFile: (filePath: string) => readFile(filePath, \"utf-8\"),\n  exists: existsSync,\n  ensureDir: (directoryPath: string) => mkdir(directoryPath, { recursive: true }).then(() => {}),\n};\n\n// ── System task registry ──────────────────────────────────────────\n\nexport interface SystemTaskDef {\n  id: string;\n  name: string;\n  description: string;\n  schedule: TaskDefinition[\"schedule\"];\n  missedRunPolicy: typeof MISSED_RUN_POLICIES.skip | typeof MISSED_RUN_POLICIES.runOnce | typeof MISSED_RUN_POLICIES.runAll;\n  run: () => Promise<void>;\n}\n\n// ── Public API ────────────────────────────────────────────────────\n\nlet stateMap: StateMap = new Map();\nconst systemTasks: SystemTaskDef[] = [];\nlet taskManagerRef: ITaskManager | null = null;\n\n/**\n * Initialize the scheduler adapter. Call once at server startup AFTER the\n * task-manager is created but BEFORE `taskManager.start()`.\n */\nexport async function initScheduler(taskManager: ITaskManager, tasks: SystemTaskDef[]): Promise<void> {\n  await mkdir(path.dirname(stateFilePath()), { recursive: true });\n  await mkdir(logsDir(), { recursive: true });\n\n  stateMap = await loadState(stateFilePath(), stateDeps());\n  systemTasks.length = 0;\n  systemTasks.push(...tasks);\n  taskManagerRef = taskManager;\n\n  // Run catch-up\n  const catchUpTasks: CatchUpTask[] = tasks.map((taskDef) => ({\n    id: taskDef.id,\n    name: taskDef.name,\n    schedule: toCoreSchedule(taskDef.schedule),\n    missedRunPolicy: taskDef.missedRunPolicy,\n    enabled: true,\n  }));\n  const plan = computeCatchUpPlan(catchUpTasks, stateMap, Date.now());\n\n  for (const skip of plan.skipped) {\n    logger().info(\"catch-up skipped\", { taskId: skip.taskId, windows: skip.windowCount });\n    await safeUpdateState(skip.taskId, { lastRunAt: skip.lastWindow });\n  }\n\n  if (plan.runs.length > 0) {\n    logger().info(\"catch-up enqueued\", { runs: plan.runs.length });\n    for (const run of plan.runs) {\n      const task = tasks.find((taskDef) => taskDef.id === run.taskId);\n      if (!task) continue;\n      await executeAndLog(task, run.context.scheduledFor, TASK_TRIGGERS.catchUp);\n    }\n  }\n\n  // Register with task-manager for ongoing ticks\n  for (const task of tasks) {\n    taskManager.registerTask({\n      id: task.id,\n      description: task.description,\n      schedule: task.schedule,\n      run: async () => {\n        const windowIso = computeCurrentWindow(task);\n        await executeAndLog(task, windowIso, TASK_TRIGGERS.scheduled);\n      },\n    });\n  }\n\n  logger().info(\"initialized\", { tasks: tasks.map((taskDef) => taskDef.id), stateEntries: stateMap.size });\n}\n\n/** Apply a schedule override to a running system task. Updates the\n *  in-memory task definition, the task-manager, and recalculates\n *  nextScheduledAt in persisted state. */\nexport async function applyScheduleOverride(taskId: string, schedule: SystemTaskDef[\"schedule\"]): Promise<boolean> {\n  const task = systemTasks.find((taskDef) => taskDef.id === taskId);\n  if (!task || !taskManagerRef) return false;\n  if (!taskManagerRef.updateSchedule(taskId, schedule)) return false;\n  task.schedule = schedule;\n\n  // Recalculate next window so the UI reflects the new schedule\n  const nextScheduledAt = computeNextScheduled(task);\n  await safeUpdateState(taskId, { nextScheduledAt });\n\n  return true;\n}\n\n/** Query execution logs — used by API routes. */\nexport async function getSchedulerLogs(opts: { since?: string; taskId?: string; limit?: number }): Promise<TaskLogEntry[]> {\n  return queryLog(logsDir(), opts, logDeps);\n}\n\n/** Get all task states — used by API routes. */\nexport function getSchedulerTasks(): {\n  id: string;\n  name: string;\n  description: string;\n  schedule: TaskDefinition[\"schedule\"];\n  missedRunPolicy: string;\n  state: TaskExecutionState;\n}[] {\n  return systemTasks.map((taskDef) => ({\n    id: taskDef.id,\n    name: taskDef.name,\n    description: taskDef.description,\n    schedule: taskDef.schedule,\n    missedRunPolicy: taskDef.missedRunPolicy,\n    state: stateMap.get(taskDef.id) ?? emptyState(taskDef.id),\n  }));\n}\n\n/** Test-only: clear config + in-memory state. */\nexport function resetSchedulerForTesting(): void {\n  config = null;\n  stateMap = new Map();\n  systemTasks.length = 0;\n  taskManagerRef = null;\n}\n\n// ── Internal ──────────────────────────────────────────────────────\n\nasync function executeAndLog(task: SystemTaskDef, scheduledFor: string, trigger: TaskTrigger): Promise<void> {\n  const startedAt = new Date().toISOString();\n  const startMs = Date.now();\n  let errMsg: string | null = null;\n  try {\n    await task.run();\n  } catch (err) {\n    errMsg = errorMessage(err);\n    logger().error(\"task failed\", { taskId: task.id, error: errMsg });\n  }\n  const durationMs = Date.now() - startMs;\n  // Persistence is best-effort — never let disk failures propagate to the\n  // tick loop or abort startup catch-up.\n  await safePersist(task, scheduledFor, startedAt, durationMs, trigger, errMsg);\n}\n\n/** Best-effort persistence — state and log are independent. A failure in\n *  one does not block the other, and neither propagates upward. */\nasync function safePersist(\n  task: SystemTaskDef,\n  scheduledFor: string,\n  startedAt: string,\n  durationMs: number,\n  trigger: TaskTrigger,\n  errMsg: string | null,\n): Promise<void> {\n  const isSuccess = errMsg === null;\n  const currentState = stateMap.get(task.id);\n  try {\n    await updateAndSave(\n      stateFilePath(),\n      stateMap,\n      task.id,\n      {\n        lastRunAt: scheduledFor,\n        lastRunResult: isSuccess ? TASK_RESULTS.success : TASK_RESULTS.error,\n        lastRunDurationMs: durationMs,\n        lastErrorMessage: errMsg,\n        consecutiveFailures: isSuccess ? 0 : (currentState?.consecutiveFailures ?? 0) + 1,\n        totalRuns: (currentState?.totalRuns ?? 0) + 1,\n        nextScheduledAt: computeNextScheduled(task),\n      },\n      stateDeps(),\n    );\n  } catch (err) {\n    logger().warn(\"state persistence failed\", { taskId: task.id, error: String(err) });\n  }\n  try {\n    await appendLogEntry(\n      logsDir(),\n      {\n        taskId: task.id,\n        taskName: task.name,\n        scheduledFor,\n        startedAt,\n        completedAt: new Date().toISOString(),\n        result: isSuccess ? TASK_RESULTS.success : TASK_RESULTS.error,\n        durationMs,\n        trigger,\n        ...(errMsg !== null && { errorMessage: errMsg }),\n      },\n      logDeps,\n    );\n  } catch (err) {\n    logger().warn(\"log persistence failed\", { taskId: task.id, error: String(err) });\n  }\n}\n\n/** Safe state update — swallows errors. */\nasync function safeUpdateState(taskId: string, patch: Partial<TaskExecutionState>): Promise<void> {\n  try {\n    await updateAndSave(stateFilePath(), stateMap, taskId, patch, stateDeps());\n  } catch (err) {\n    logger().warn(\"state update failed\", { taskId, error: String(err) });\n  }\n}\n\n/** Compute the window boundary that the current tick belongs to. For\n *  scheduled runs, this is the epoch-aligned window — not the wall-clock\n *  time of execution. This keeps lastRunAt consistent with catch-up's\n *  window-based accounting. */\nfunction computeCurrentWindow(task: SystemTaskDef): string {\n  const coreSchedule = toCoreSchedule(task.schedule);\n  // The window that just fired is the latest one at or before now.\n  const nowMs = Date.now();\n  const windowMs = nextWindowAfter(coreSchedule, nowMs - (coreSchedule.type === SCHEDULE_TYPES.interval ? coreSchedule.intervalSec * ONE_SECOND_MS : 0));\n  return windowMs !== null && windowMs <= nowMs ? new Date(windowMs).toISOString() : new Date(nowMs).toISOString();\n}\n\nfunction computeNextScheduled(task: SystemTaskDef): string | null {\n  const coreSchedule = toCoreSchedule(task.schedule);\n  const next = nextWindowAfter(coreSchedule, Date.now() + 1);\n  return next !== null ? new Date(next).toISOString() : null;\n}\n\nfunction toCoreSchedule(schedule: TaskDefinition[\"schedule\"]): TaskSchedule {\n  if (schedule.type === SCHEDULE_TYPES.interval) {\n    return {\n      type: SCHEDULE_TYPES.interval,\n      intervalSec: Math.round(schedule.intervalMs / ONE_SECOND_MS),\n    };\n  }\n  return schedule;\n}\n"],"mappings":"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"}

package/dist/scheduler/index.d.ts

@@ -0,0 +1,2 @@
+export { createTaskManager, type ITaskManager, type TaskDefinition, type TaskSchedule, type TaskRunContext, type TaskManagerOptions, type SchedulerLogger, } from './task-manager.js';
+export { configureScheduler, initScheduler, applyScheduleOverride, getSchedulerLogs, getSchedulerTasks, resetSchedulerForTesting, type SchedulerConfig, type SystemTaskDef, } from './adapter.js';