@interactive-inc/claude-funnel 0.60.1 → 0.64.0

package/dist/{schedule-connector-L4uzg5M8.js → schedule-connector-9k3gOIgl.js}

@@ -1,7 +1,8 @@
-import { t as NodeFunnelFileSystem } from "./node-file-system-Blr8pAir.js";
-import { t as FunnelConnectorListener } from "./connector-listener-DR3aKOuK.js";
-import { n as scheduleConnectorSchema, r as scheduleEntrySchema } from "./schedule-connector-schema-CfyuMCMh.js";
-import { t as errorMessageOf } from "./error-message-of-Byi4y0Uf.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-BOXIHW_Q.js";
+import { t as errorMessageOf } from "./error-message-of-ColuYmAk.js";
+import { t as FunnelConnectorListener } from "./connector-listener-mPGZYa8e.js";
+import { n as scheduleConnectorSchema, r as scheduleEntrySchema } from "./schedule-connector-schema-DKEPZnVv.js";
+import { t as FunnelConnectorDiagnosticsRecorder } from "./connector-diagnostics-recorder-COtNEmUp.js";
 import { dirname, join } from "node:path";
 import { z } from "zod";
 //#region lib/engine/connectors/match-cron.ts
@@ -87,7 +88,7 @@ const defaultFs = new NodeFunnelFileSystem();
 * connectorDir) so this store does not know about the funnel directory layout
 * (`channels/<id>/connectors/<id>/state.json` lives outside this class).
 */
-var ScheduleStateStore = class {
+var FunnelScheduleStateStore = class {
 	path;
 	fs;
 	constructor(deps) {
@@ -116,50 +117,75 @@ const MAX_CATCHUP_MINUTES = 1440;
 var FunnelScheduleListener = class extends FunnelConnectorListener {
 	config;
 	lastFiredStore;
-	channelId;
 	logger;
-	diagnosticLog;
+	diagnostics;
 	now;
 	onFired;
 	timer = null;
 	stopped = false;
+	tickScheduled = false;
 	constructor(deps) {
 		super();
 		this.config = deps.config;
 		this.lastFiredStore = deps.lastFiredStore;
-		this.channelId = deps.channelId ?? null;
 		this.logger = deps.logger;
-		this.diagnosticLog = deps.diagnosticLog;
+		this.diagnostics = new FunnelConnectorDiagnosticsRecorder({
+			type: "schedule",
+			connectorId: deps.config.id,
+			channelId: deps.channelId ?? null,
+			log: deps.diagnosticLog
+		});
 		this.now = deps.now ?? (() => /* @__PURE__ */ new Date());
 		this.onFired = deps.onFired ?? null;
 	}
 	async start(notify) {
 		this.stopped = false;
-		this.recordConnection("started", "");
+		this.tickScheduled = true;
+		this.diagnostics.recordConnection("started", "");
 		const scheduleNext = () => {
 			if (this.stopped) return;
 			const date = this.now();
 			const msUntilNextMinute = 6e4 - (date.getSeconds() * 1e3 + date.getMilliseconds());
 			this.timer = setTimeout(async () => {
 				if (this.stopped) return;
-				await this.tick(notify);
+				try {
+					await this.tick(notify);
+				} catch (error) {
+					this.recordTickError(error);
+				}
 				scheduleNext();
 			}, msUntilNextMinute);
 			this.timer.unref();
+			this.tickScheduled = true;
 		};
-		await this.tick(notify);
+		try {
+			await this.tick(notify);
+		} catch (error) {
+			this.recordTickError(error);
+		}
+		this.diagnostics.recordConnection("connected", "");
 		scheduleNext();
 	}
 	async stop() {
 		this.stopped = true;
+		this.tickScheduled = false;
 		if (this.timer) {
 			clearTimeout(this.timer);
 			this.timer = null;
 		}
-		this.recordConnection("stopped", "");
+		this.diagnostics.recordConnection("disconnected", "");
+		this.diagnostics.recordConnection("stopped", "");
+	}
+	recordTickError(error) {
+		const message = errorMessageOf(error);
+		this.diagnostics.recordConnection("error", `tick: ${message}`);
+		this.logger?.error("schedule tick failed", {
+			connector: this.config.name,
+			error: message
+		});
 	}
 	isAlive() {
-		return !this.stopped && this.timer !== null;
+		return !this.stopped && this.tickScheduled;
 	}
 	async tick(notify) {
 		const now = this.truncateToMinute(this.now());
@@ -209,14 +235,20 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 		};
 		if (catchup) meta.catchup = "true";
 		const eventId = `${entry.id}@${firedAt.toISOString()}`;
-		this.recordRaw(eventId, entry, firedAt, catchup);
+		this.diagnostics.recordRaw(eventId, JSON.stringify({
+			schedule_id: entry.id,
+			cron: entry.cron,
+			prompt: entry.prompt,
+			fired_at: firedAt.toISOString(),
+			catchup
+		}));
 		try {
 			await notify(entry.prompt, meta);
 		} catch (error) {
-			this.recordProcessed(eventId, entry, "emitted:delivery-failed");
+			this.diagnostics.recordProcessed(eventId, "emitted:delivery-failed", entry.prompt);
 			throw error;
 		}
-		this.recordProcessed(eventId, entry, "emitted");
+		this.diagnostics.recordProcessed(eventId, "emitted", entry.prompt);
 		if (this.onFired) try {
 			await this.onFired(entry, firedAt);
 		} catch (error) {
@@ -263,7 +295,7 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 	}
 	logInvalidCron(entry, error) {
 		const message = errorMessageOf(error);
-		this.recordConnection("error", `invalid cron "${entry.cron}" (entry ${entry.id}): ${message}`);
+		this.diagnostics.recordConnection("error", `invalid cron "${entry.cron}" (entry ${entry.id}): ${message}`);
 		this.logger?.error("invalid cron expression in schedule", {
 			connector: this.config.name,
 			id: entry.id,
@@ -276,40 +308,6 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 		copy.setSeconds(0, 0);
 		return copy;
 	}
-	recordRaw(eventId, entry, firedAt, catchup) {
-		this.diagnosticLog?.recordRaw({
-			eventId,
-			type: "schedule",
-			connectorId: this.config.id,
-			channelId: this.channelId,
-			payload: JSON.stringify({
-				schedule_id: entry.id,
-				cron: entry.cron,
-				prompt: entry.prompt,
-				fired_at: firedAt.toISOString(),
-				catchup
-			})
-		});
-	}
-	recordProcessed(eventId, entry, outcome) {
-		this.diagnosticLog?.recordProcessed({
-			eventId,
-			type: "schedule",
-			connectorId: this.config.id,
-			channelId: this.channelId,
-			outcome,
-			payload: entry.prompt
-		});
-	}
-	recordConnection(status, detail) {
-		this.diagnosticLog?.recordConnection({
-			type: "schedule",
-			connectorId: this.config.id,
-			channelId: this.channelId,
-			status,
-			detail
-		});
-	}
 };
 //#endregion
 //#region lib/engine/connectors/schedule-connector.ts
@@ -335,14 +333,15 @@ const scheduleConnector = (options = {}) => ({
 		const parsed = scheduleConnectorSchema.parse(config);
 		return new FunnelScheduleListener({
 			config: parsed,
-			lastFiredStore: new ScheduleStateStore({
+			lastFiredStore: new FunnelScheduleStateStore({
 				path: join(deps.connectorDir(deps.channelId, parsed.id), "state.json"),
 				fs: deps.fs
 			}),
 			channelId: deps.channelId,
 			logger: deps.logger,
 			diagnosticLog: deps.diagnosticLog,
-			onFired: options.onFired
+			onFired: options.onFired,
+			now: () => deps.clock.now()
 		});
 	},
 	createAdapter: null,
@@ -409,4 +408,4 @@ const scheduleConnector = (options = {}) => ({
 	}
 });
 //#endregion
-export { matchCron as i, FunnelScheduleListener as n, ScheduleStateStore as r, scheduleConnector as t };
+export { matchCron as i, FunnelScheduleListener as n, FunnelScheduleStateStore as r, scheduleConnector as t };

package/dist/schedule-connector-schema-Z0RXLgPI.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+
+//#region lib/engine/connectors/schedule-connector-schema.d.ts
+/**
+ * Catch-up behavior when the daemon was down past one or more matching minutes.
+ *
+ * - `latest`: fire once with the most recent missed match (default; preserves prior behavior).
+ * - `all`: fire once per missed minute, oldest first (capped at 24 h).
+ * - `skip`: never fire missed matches; only fire when the current minute matches.
+ */
+declare const scheduleCatchupPolicySchema: z.ZodEnum<{
+  latest: "latest";
+  all: "all";
+  skip: "skip";
+}>;
+type ScheduleCatchupPolicy = z.infer<typeof scheduleCatchupPolicySchema>;
+declare const scheduleEntrySchema: z.ZodObject<{
+  id: z.ZodString;
+  cron: z.ZodString;
+  prompt: z.ZodString;
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  catchupPolicy: z.ZodDefault<z.ZodEnum<{
+    latest: "latest";
+    all: "all";
+    skip: "skip";
+  }>>;
+}, z.core.$strip>;
+type ScheduleEntry = z.infer<typeof scheduleEntrySchema>;
+declare const scheduleConnectorSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"schedule">;
+  entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    cron: z.ZodString;
+    prompt: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    catchupPolicy: z.ZodDefault<z.ZodEnum<{
+      latest: "latest";
+      all: "all";
+      skip: "skip";
+    }>>;
+  }, z.core.$strip>>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ScheduleConnectorConfig = z.infer<typeof scheduleConnectorSchema>;
+//#endregion
+export { scheduleConnectorSchema as a, scheduleCatchupPolicySchema as i, ScheduleConnectorConfig as n, scheduleEntrySchema as o, ScheduleEntry as r, ScheduleCatchupPolicy as t };

package/dist/settings-reader-BNxjsxCB.d.ts

@@ -0,0 +1,27 @@
+import { a as Settings } from "./settings-schema-BL_c2Udm.js";
+
+//#region lib/engine/id/id-generator.d.ts
+/**
+ * ID generator boundary. Default NodeFunnelIdGenerator wraps `crypto.randomUUID()`;
+ * MemoryFunnelIdGenerator emits `<prefix>-1, <prefix>-2, ...` for deterministic tests.
+ */
+declare abstract class FunnelIdGenerator {
+  abstract generate(): string;
+}
+//#endregion
+//#region lib/engine/settings/settings-reader.d.ts
+declare abstract class FunnelSettingsReader {
+  abstract read(): Settings;
+  abstract write(settings: Settings): void;
+  /**
+   * Atomic read-modify-write. Implementations must serialize against
+   * concurrent processes touching the same file (the Node store does so via
+   * an exclusive lockfile; Memory stores are single-threaded). Engine
+   * classes must use `update` for any mutation that depends on prior state,
+   * otherwise a concurrent CLI invocation or `fnl claude` launch can lose
+   * the edit through a read-modify-write race.
+   */
+  abstract update<T>(mutator: (settings: Settings) => T): T;
+}
+//#endregion
+export { FunnelIdGenerator as n, FunnelSettingsReader as t };

package/dist/{settings-store-CUKSeTXC.js → settings-store-C2QdOH-t.js}

@@ -1,5 +1,5 @@
-import { t as NodeFunnelFileSystem } from "./node-file-system-Blr8pAir.js";
-import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-CtQ-Ix8_.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-BOXIHW_Q.js";
+import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-9FcX3qS1.js";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { z } from "zod";
@@ -29,11 +29,11 @@ const baseConnectorConfigSchema = z.object({
 //#region lib/engine/settings/settings-schema.ts
 /**
 * Connectors are stored loosely here: settings validates only the common base
-* fields and preserves every type-specific key verbatim (`.passthrough()`).
+* fields and preserves every type-specific key verbatim (`.loose()`).
 * Core does not enumerate connector types, so strict per-type validation happens
 * at the registry/descriptor layer (CRUD time), not on every settings read.
 */
-const storedConnectorSchema = baseConnectorConfigSchema.passthrough();
+const storedConnectorSchema = baseConnectorConfigSchema.loose();
 /**
 * Routing mode when multiple WS clients are subscribed to the same channel.
 *
@@ -192,6 +192,25 @@ var FunnelSettingsStore = class extends FunnelSettingsReader {
 		};
 		this.fs.writeSecretFileSync(this.path, `${JSON.stringify(versioned, null, 2)}\n`);
 	}
+	/**
+	* Run `mutator` against a freshly-read settings object inside an exclusive
+	* file lock, then persist the result. Use this instead of bare `read()` +
+	* `write()` for any logical edit (add channel, set token, rename profile),
+	* so two concurrent CLI invocations or `fnl claude` launches cannot lose
+	* each other's updates via a read-modify-write race. The mutator may
+	* mutate `settings` in place and/or return a value; the value is returned
+	* to the caller. A thrown error from the mutator skips the write but still
+	* releases the lock.
+	*/
+	update(mutator) {
+		this.fs.mkdirSync(dirname(this.path), { recursive: true });
+		return this.fs.withFileLock(`${this.path}.lock`, () => {
+			const settings = this.read();
+			const result = mutator(settings);
+			this.write(settings);
+			return result;
+		});
+	}
 };
 //#endregion
 export { resolveFunnelDir as a, channelConfigSchema as c, settingsSchema as d, baseConnectorConfigSchema as f, SETTINGS_PATH as i, channelDeliveryModeSchema as l, FUNNEL_DIR as n, resolveFunnelPort as o, NodeFunnelIdGenerator as p, FunnelSettingsStore as r, SETTINGS_VERSION as s, DEFAULT_GATEWAY_PORT as t, profileConfigSchema as u };