@interactive-inc/claude-funnel 0.41.0 → 0.50.0

package/dist/memory-token-prompter-B5FFCsGP.d.ts

@@ -0,0 +1,57 @@
+import { n as FunnelFileSystem } from "./file-system-BeOKXjlV.js";
+import { i as FunnelTokenPrompter } from "./local-config-sync-BdsrDZOu.js";
+
+//#region lib/engine/local-config/local-config-json-schema.d.ts
+/**
+ * Generates the JSON Schema (draft 2020-12) for `funnel.json`. Useful for
+ * `$schema` references in committed `funnel.json` files so editors can give
+ * autocomplete and validation for channels[] (transport) and profiles[]
+ * (launch recipe) without anyone hand-maintaining a separate schema.
+ */
+declare const funnelJsonSchema: () => Record<string, unknown>;
+//#endregion
+//#region lib/engine/local-config/local-config-writer.d.ts
+type Deps = {
+  fs: FunnelFileSystem;
+};
+/**
+ * The one path that mutates the repo-committed funnel.json, and it only ever
+ * inserts `id`. On first launch a repo has no `id`; funnel generates one and
+ * writes it back here so future launches resolve the same `~/.funnel/projects/<id>/`.
+ * Idempotent — a no-op once `id` is present. Kept separate from the read-only
+ * FunnelLocalConfig so reads stay side-effect free.
+ */
+declare class FunnelLocalConfigWriter {
+  private readonly fs;
+  constructor(deps: Deps);
+  ensureId(cwd: string, id: string): void;
+}
+//#endregion
+//#region lib/engine/token-prompter/node-token-prompter.d.ts
+/**
+ * Reads a secret from stdin in raw mode. Echoes a `*` per byte so the user
+ * can see progress without exposing the token. Refuses to prompt when stdin
+ * is not a TTY — callers should surface the resulting error with a hint
+ * pointing at the corresponding env var or CLI command.
+ */
+declare class NodeFunnelTokenPrompter extends FunnelTokenPrompter {
+  promptSecret(label: string): Promise<string>;
+  private readSecret;
+}
+//#endregion
+//#region lib/engine/token-prompter/memory-token-prompter.d.ts
+type Props = {
+  answers?: Record<string, string>;
+};
+/**
+ * Pre-seeded answers keyed by prompt label. Tests configure the map up front;
+ * unmapped labels throw so the test surfaces unexpected prompts loudly.
+ */
+declare class MemoryFunnelTokenPrompter extends FunnelTokenPrompter {
+  private readonly answers;
+  readonly asked: string[];
+  constructor(props?: Props);
+  promptSecret(label: string): Promise<string>;
+}
+//#endregion
+export { funnelJsonSchema as i, NodeFunnelTokenPrompter as n, FunnelLocalConfigWriter as r, MemoryFunnelTokenPrompter as t };

package/dist/memory-token-prompter-CLerGsgM.js

@@ -0,0 +1,61 @@
+import { i as FunnelTokenPrompter, o as LOCAL_CONFIG_FILENAME } from "./local-config-json-schema-8IHjS4Q7.js";
+import { join } from "node:path";
+//#region lib/engine/local-config/local-config-writer.ts
+const isRecord = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const withIdFirst = (config, id) => {
+	const ordered = {};
+	if (config.$schema !== void 0) ordered.$schema = config.$schema;
+	ordered.id = id;
+	for (const key of Object.keys(config)) {
+		if (key === "$schema" || key === "id") continue;
+		ordered[key] = config[key];
+	}
+	return ordered;
+};
+/**
+* The one path that mutates the repo-committed funnel.json, and it only ever
+* inserts `id`. On first launch a repo has no `id`; funnel generates one and
+* writes it back here so future launches resolve the same `~/.funnel/projects/<id>/`.
+* Idempotent — a no-op once `id` is present. Kept separate from the read-only
+* FunnelLocalConfig so reads stay side-effect free.
+*/
+var FunnelLocalConfigWriter = class {
+	fs;
+	constructor(deps) {
+		this.fs = deps.fs;
+		Object.freeze(this);
+	}
+	ensureId(cwd, id) {
+		const path = join(cwd, LOCAL_CONFIG_FILENAME);
+		if (!this.fs.existsSync(path)) return;
+		const parsed = JSON.parse(this.fs.readFileSync(path));
+		if (!isRecord(parsed)) return;
+		if (typeof parsed.id === "string" && parsed.id !== "") return;
+		const ordered = withIdFirst(parsed, id);
+		this.fs.writeFileSync(path, `${JSON.stringify(ordered, null, 2)}\n`);
+	}
+};
+//#endregion
+//#region lib/engine/token-prompter/memory-token-prompter.ts
+/**
+* Pre-seeded answers keyed by prompt label. Tests configure the map up front;
+* unmapped labels throw so the test surfaces unexpected prompts loudly.
+*/
+var MemoryFunnelTokenPrompter = class extends FunnelTokenPrompter {
+	answers;
+	asked = [];
+	constructor(props = {}) {
+		super();
+		this.answers = new Map(Object.entries(props.answers ?? {}));
+	}
+	async promptSecret(label) {
+		this.asked.push(label);
+		const answer = this.answers.get(label);
+		if (answer === void 0) throw new Error(`no answer seeded for prompt "${label}"`);
+		return answer;
+	}
+};
+//#endregion
+export { FunnelLocalConfigWriter as n, MemoryFunnelTokenPrompter as t };

package/dist/node-file-system-BcrmWN9I.js

@@ -0,0 +1,48 @@
+import { t as FunnelFileSystem } from "./file-system-PWKKU7lA.js";
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+//#region lib/engine/fs/node-file-system.ts
+const SECRET_MODE = 384;
+var NodeFunnelFileSystem = class extends FunnelFileSystem {
+	constructor() {
+		super();
+		Object.freeze(this);
+	}
+	existsSync(path) {
+		return existsSync(path);
+	}
+	readFileSync(path) {
+		return readFileSync(path, "utf-8");
+	}
+	writeFileSync(path, data) {
+		writeFileSync(path, data);
+	}
+	writeSecretFileSync(path, data) {
+		writeFileSync(path, data, { mode: SECRET_MODE });
+		try {
+			chmodSync(path, SECRET_MODE);
+		} catch {}
+	}
+	appendFileSync(path, data) {
+		appendFileSync(path, data);
+	}
+	unlink(path) {
+		try {
+			unlinkSync(path);
+		} catch {}
+	}
+	mkdirSync(path, options) {
+		mkdirSync(path, { recursive: options?.recursive ?? false });
+	}
+	readdirSync(path) {
+		return readdirSync(path);
+	}
+	statSync(path) {
+		const stat = statSync(path);
+		return {
+			mtimeMs: stat.mtimeMs,
+			mode: stat.mode & 511
+		};
+	}
+};
+//#endregion
+export { NodeFunnelFileSystem as t };

package/dist/{gh-connector-schema-CQmEWzdV.d.ts → process-runner-DfniuWVU.d.ts}

@@ -1,5 +1,3 @@
-import { z } from "zod";
-
 //#region lib/engine/process/process-runner.d.ts
 type RunOptions = {
   cwd?: string;
@@ -48,15 +46,4 @@ declare abstract class FunnelProcessRunner {
   abstract listProcessesContaining(marker: string): ProcessSnapshot[];
 }
 //#endregion
-//#region lib/connectors/gh-connector-schema.d.ts
-declare const ghConnectorSchema: z.ZodObject<{
-  id: z.ZodString;
-  name: z.ZodString;
-  type: z.ZodLiteral<"gh">;
-  pollInterval: z.ZodOptional<z.ZodNumber>;
-  createdAt: z.ZodOptional<z.ZodString>;
-  updatedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type GhConnectorConfig = z.infer<typeof ghConnectorSchema>;
-//#endregion
-export { FunnelProcessRunner as a, RunResult as c, DetachOptions as i, ghConnectorSchema as n, ProcessSnapshot as o, AttachOptions as r, RunOptions as s, GhConnectorConfig as t };
+export { RunOptions as a, ProcessSnapshot as i, DetachOptions as n, RunResult as o, FunnelProcessRunner as r, AttachOptions as t };

package/dist/profiles-f0mNmEyP.d.ts

@@ -0,0 +1,64 @@
+import { a as ProfileConfig, n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-BSU6JyvM.js";
+import { n as FunnelFileSystem } from "./file-system-BeOKXjlV.js";
+
+//#region lib/engine/profiles/profiles.d.ts
+type Deps = {
+  store: FunnelSettingsReader;
+  idGenerator: FunnelIdGenerator;
+  fs?: FunnelFileSystem;
+};
+/**
+ * Named launch presets for `fnl claude`. Each profile bundles a working
+ * directory, the channel id its Claude instance subscribes to, and the launch
+ * recipe (`options` prepended to the claude argv, `env` layered under the
+ * process, `resume` toggling session reuse). Implements ProfileChannelChecker
+ * so FunnelChannels can refuse to remove a channel that is still referenced.
+ *
+ * Each profile has a stable `id` (uuid) minted at `add`. That id is the unit
+ * everything internal keys on — the PID file, the resumable session id — so a
+ * rename never strands either. `name` is purely the CLI/TUI handle; the CRUD
+ * methods here take it because that is what the user types, but resolve to the
+ * id before touching id-keyed state. The first array entry is the default
+ * profile; `asDefault` reorders to put one first.
+ *
+ * `channelId` always stores the channel's stable id (uuid). CLI surfaces
+ * resolve channel name → id before calling `add`/`update` here.
+ */
+declare class FunnelProfiles {
+  private readonly store;
+  private readonly idGenerator;
+  private readonly fs;
+  constructor(deps: Deps);
+  list(): ProfileConfig[];
+  get(name: string): ProfileConfig | null;
+  getById(id: string): ProfileConfig | null;
+  getDefault(): ProfileConfig | null;
+  add(input: {
+    name: string;
+    path: string;
+    channelId: string;
+    options?: string[];
+    env?: Record<string, string>;
+    resume?: boolean;
+  }): void;
+  remove(name: string): void;
+  rename(oldName: string, newName: string): void;
+  asDefault(name: string): void;
+  hasChannelRef(channelId: string): boolean;
+  /** Resumable claude session id last launched by this profile (by id), or null. */
+  getSessionId(id: string): string | null;
+  /** Records the claude session id this profile launched, overwriting any prior one. */
+  setSessionId(id: string, sessionId: string): void;
+  /**
+   * Mirrors claude's session storage path
+   * (`<config-dir>/projects/<cwd-with-slashes-as-dashes>/<id>.jsonl`) to check
+   * whether a recorded session still exists AND is non-empty. Reads the same
+   * `CLAUDE_CONFIG_DIR` the child will run under so the check matches reality; a
+   * wrong guess can only ever produce a false negative (start fresh), never a
+   * bad resume.
+   */
+  sessionFileExists(cwd: string, sessionId: string, env: Record<string, string>): boolean;
+  update(name: string, fields: Partial<Omit<ProfileConfig, "name">>): void;
+}
+//#endregion
+export { FunnelProfiles as t };

package/dist/profiles-wMRnjSid.js

@@ -0,0 +1,129 @@
+import { t as NodeFunnelFileSystem } from "./node-file-system-BcrmWN9I.js";
+import { join } from "node:path";
+import { homedir } from "node:os";
+//#region lib/engine/profiles/profiles.ts
+const defaultFs = new NodeFunnelFileSystem();
+/**
+* Named launch presets for `fnl claude`. Each profile bundles a working
+* directory, the channel id its Claude instance subscribes to, and the launch
+* recipe (`options` prepended to the claude argv, `env` layered under the
+* process, `resume` toggling session reuse). Implements ProfileChannelChecker
+* so FunnelChannels can refuse to remove a channel that is still referenced.
+*
+* Each profile has a stable `id` (uuid) minted at `add`. That id is the unit
+* everything internal keys on — the PID file, the resumable session id — so a
+* rename never strands either. `name` is purely the CLI/TUI handle; the CRUD
+* methods here take it because that is what the user types, but resolve to the
+* id before touching id-keyed state. The first array entry is the default
+* profile; `asDefault` reorders to put one first.
+*
+* `channelId` always stores the channel's stable id (uuid). CLI surfaces
+* resolve channel name → id before calling `add`/`update` here.
+*/
+var FunnelProfiles = class {
+	store;
+	idGenerator;
+	fs;
+	constructor(deps) {
+		this.store = deps.store;
+		this.idGenerator = deps.idGenerator;
+		this.fs = deps.fs ?? defaultFs;
+		Object.freeze(this);
+	}
+	list() {
+		return this.store.read().profiles;
+	}
+	get(name) {
+		return this.list().find((p) => p.name === name) ?? null;
+	}
+	getById(id) {
+		return this.list().find((p) => p.id === id) ?? null;
+	}
+	getDefault() {
+		return this.list()[0] ?? null;
+	}
+	add(input) {
+		const settings = this.store.read();
+		if (settings.profiles.some((p) => p.name === input.name)) throw new Error(`profile "${input.name}" already exists`);
+		if (!settings.channels.some((c) => c.id === input.channelId)) throw new Error(`channel id "${input.channelId}" not found`);
+		settings.profiles.push({
+			id: this.idGenerator.generate(),
+			name: input.name,
+			path: input.path,
+			channelId: input.channelId,
+			options: input.options ?? [],
+			env: input.env ?? {},
+			resume: input.resume ?? true
+		});
+		this.store.write(settings);
+	}
+	remove(name) {
+		const settings = this.store.read();
+		const index = settings.profiles.findIndex((p) => p.name === name);
+		if (index < 0) throw new Error(`profile "${name}" not found`);
+		settings.profiles.splice(index, 1);
+		this.store.write(settings);
+	}
+	rename(oldName, newName) {
+		const settings = this.store.read();
+		const profile = settings.profiles.find((p) => p.name === oldName);
+		if (!profile) throw new Error(`profile "${oldName}" not found`);
+		if (settings.profiles.some((p) => p.name === newName)) throw new Error(`profile "${newName}" already exists`);
+		profile.name = newName;
+		this.store.write(settings);
+	}
+	asDefault(name) {
+		const settings = this.store.read();
+		const index = settings.profiles.findIndex((p) => p.name === name);
+		if (index < 0) throw new Error(`profile "${name}" not found`);
+		if (index === 0) return;
+		const [profile] = settings.profiles.splice(index, 1);
+		if (!profile) return;
+		settings.profiles.unshift(profile);
+		this.store.write(settings);
+	}
+	hasChannelRef(channelId) {
+		return this.store.read().profiles.some((p) => p.channelId === channelId);
+	}
+	/** Resumable claude session id last launched by this profile (by id), or null. */
+	getSessionId(id) {
+		return this.getById(id)?.sessionId ?? null;
+	}
+	/** Records the claude session id this profile launched, overwriting any prior one. */
+	setSessionId(id, sessionId) {
+		const settings = this.store.read();
+		const profile = settings.profiles.find((p) => p.id === id);
+		if (!profile) throw new Error(`profile id "${id}" not found`);
+		profile.sessionId = sessionId;
+		this.store.write(settings);
+	}
+	/**
+	* Mirrors claude's session storage path
+	* (`<config-dir>/projects/<cwd-with-slashes-as-dashes>/<id>.jsonl`) to check
+	* whether a recorded session still exists AND is non-empty. Reads the same
+	* `CLAUDE_CONFIG_DIR` the child will run under so the check matches reality; a
+	* wrong guess can only ever produce a false negative (start fresh), never a
+	* bad resume.
+	*/
+	sessionFileExists(cwd, sessionId, env) {
+		const path = join(env.CLAUDE_CONFIG_DIR ?? globalThis.process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"), "projects", cwd.replace(/\//g, "-"), `${sessionId}.jsonl`);
+		if (!this.fs.existsSync(path)) return false;
+		return this.fs.readFileSync(path).trim().length > 0;
+	}
+	update(name, fields) {
+		const settings = this.store.read();
+		const profile = settings.profiles.find((p) => p.name === name);
+		if (!profile) throw new Error(`profile "${name}" not found`);
+		if (fields.channelId !== void 0) {
+			if (!settings.channels.some((c) => c.id === fields.channelId)) throw new Error(`channel id "${fields.channelId}" not found`);
+			profile.channelId = fields.channelId;
+		}
+		if (fields.path !== void 0) profile.path = fields.path;
+		if (fields.options !== void 0) profile.options = fields.options;
+		if (fields.env !== void 0) profile.env = fields.env;
+		if (fields.resume !== void 0) profile.resume = fields.resume;
+		this.store.write(settings);
+	}
+};
+//#endregion
+export { FunnelProfiles as t };

package/dist/profiles.d.ts

@@ -0,0 +1,2 @@
+import { t as FunnelProfiles } from "./profiles-f0mNmEyP.js";
+export { FunnelProfiles };

package/dist/profiles.js

@@ -0,0 +1,2 @@
+import { t as FunnelProfiles } from "./profiles-wMRnjSid.js";
+export { FunnelProfiles };

package/dist/schedule-connector-schema-iCI61gzU.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+//#region lib/connectors/schedule-connector-schema.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.
+*/
+const scheduleCatchupPolicySchema = z.enum([
+	"latest",
+	"all",
+	"skip"
+]);
+const scheduleEntrySchema = z.object({
+	id: z.string(),
+	cron: z.string(),
+	prompt: z.string(),
+	enabled: z.boolean().default(true),
+	catchupPolicy: scheduleCatchupPolicySchema.default("latest")
+});
+const scheduleConnectorSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	type: z.literal("schedule"),
+	entries: z.array(scheduleEntrySchema).default([]),
+	createdAt: z.string().datetime().optional(),
+	updatedAt: z.string().datetime().optional()
+});
+//#endregion
+export { scheduleConnectorSchema as n, scheduleEntrySchema as r, scheduleCatchupPolicySchema as t };

package/dist/{schedule-listener-3M6WkH1Y.d.ts → schedule-listener-CUyUFFR1.d.ts}

@@ -1,6 +1,26 @@
-import { S as NotifyFn, b as FunnelLogger, o as ConnectorDiagnosticLog, x as FunnelConnectorListener } from "./connector-diagnostic-log-OPpPi9V9.js";
+import { S as FunnelLogger, b as FunnelConnectorListener, o as ConnectorDiagnosticLog, x as NotifyFn } from "./connector-diagnostic-log-yTOojKUR.js";
+import { n as FunnelFileSystem } from "./file-system-BeOKXjlV.js";
 import { z } from "zod";
 
+//#region lib/connectors/schedule-state-store.d.ts
+type Deps$1 = {
+  path: string;
+  fs?: FunnelFileSystem;
+};
+/**
+ * Per-connector lastFiredAt persistence for the schedule listener. The path is
+ * passed in by FunnelConnectorFactory so this store does not know about the
+ * funnel directory layout (`channels/<id>/connectors/<id>/state.json` lives
+ * outside this class).
+ */
+declare class ScheduleStateStore {
+  private readonly path;
+  private readonly fs;
+  constructor(deps: Deps$1);
+  load(): Map<string, Date>;
+  save(state: Map<string, Date>): void;
+}
+//#endregion
 //#region lib/connectors/schedule-connector-schema.d.ts
 /**
  * Catch-up behavior when the daemon was down past one or more matching minutes.
@@ -47,50 +67,6 @@ declare const scheduleConnectorSchema: z.ZodObject<{
 }, z.core.$strip>;
 type ScheduleConnectorConfig = z.infer<typeof scheduleConnectorSchema>;
 //#endregion
-//#region lib/engine/fs/file-system.d.ts
-type FileStat = {
-  mtimeMs: number; /** POSIX mode bits (e.g. 0o600). `null` when the underlying FS does not expose mode. */
-  mode: number | null;
-};
-/**
- * Filesystem boundary used everywhere funnel reads or writes.
- * Default is NodeFunnelFileSystem (real `node:fs`); MemoryFunnelFileSystem
- * provides a sandbox for tests and embedded use.
- */
-declare abstract class FunnelFileSystem {
-  abstract existsSync(path: string): boolean;
-  abstract readFileSync(path: string): string;
-  abstract writeFileSync(path: string, data: string): void;
-  /** Write `data` and ensure the resulting file is owner-only (0600). Use for tokens and any file that may contain secrets. */
-  abstract writeSecretFileSync(path: string, data: string): void;
-  abstract appendFileSync(path: string, data: string): void;
-  abstract unlink(path: string): void;
-  abstract mkdirSync(path: string, options?: {
-    recursive?: boolean;
-  }): void;
-  abstract readdirSync(path: string): string[];
-  abstract statSync(path: string): FileStat;
-}
-//#endregion
-//#region lib/connectors/schedule-state-store.d.ts
-type Deps$1 = {
-  path: string;
-  fs?: FunnelFileSystem;
-};
-/**
- * Per-connector lastFiredAt persistence for the schedule listener. The path is
- * passed in by FunnelConnectorFactory so this store does not know about the
- * funnel directory layout (`channels/<id>/connectors/<id>/state.json` lives
- * outside this class).
- */
-declare class ScheduleStateStore {
-  private readonly path;
-  private readonly fs;
-  constructor(deps: Deps$1);
-  load(): Map<string, Date>;
-  save(state: Map<string, Date>): void;
-}
-//#endregion
 //#region lib/connectors/schedule-listener.d.ts
 type ScheduleOnFired = (entry: ScheduleEntry, firedAt: Date) => void | Promise<void>;
 type Deps = {
@@ -133,4 +109,4 @@ declare class FunnelScheduleListener extends FunnelConnectorListener {
   private recordConnection;
 }
 //#endregion
-export { FunnelFileSystem as a, ScheduleEntry as c, scheduleEntrySchema as d, FileStat as i, scheduleCatchupPolicySchema as l, ScheduleOnFired as n, ScheduleCatchupPolicy as o, ScheduleStateStore as r, ScheduleConnectorConfig as s, FunnelScheduleListener as t, scheduleConnectorSchema as u };
+export { ScheduleEntry as a, scheduleEntrySchema as c, ScheduleConnectorConfig as i, ScheduleStateStore as l, ScheduleOnFired as n, scheduleCatchupPolicySchema as o, ScheduleCatchupPolicy as r, scheduleConnectorSchema as s, FunnelScheduleListener as t };

package/dist/{schedule-connector-schema-CM-sRkac.js → schedule-listener-ePAjians.js}

@@ -1,7 +1,6 @@
-import { n as FunnelConnectorListener } from "./logger-Czli2OKh.js";
+import { t as FunnelConnectorListener } from "./connector-listener-DU54DN-f.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-BcrmWN9I.js";
 import { dirname } from "node:path";
-import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { z } from "zod";
 //#region lib/connectors/match-cron.ts
 const parseField = (expr, min, max) => {
 	const values = /* @__PURE__ */ new Set();
@@ -67,59 +66,6 @@ const matchCron = (expr, date) => {
 	return true;
 };
 //#endregion
-//#region lib/engine/fs/file-system.ts
-/**
-* Filesystem boundary used everywhere funnel reads or writes.
-* Default is NodeFunnelFileSystem (real `node:fs`); MemoryFunnelFileSystem
-* provides a sandbox for tests and embedded use.
-*/
-var FunnelFileSystem = class {};
-//#endregion
-//#region lib/engine/fs/node-file-system.ts
-const SECRET_MODE = 384;
-var NodeFunnelFileSystem = class extends FunnelFileSystem {
-	constructor() {
-		super();
-		Object.freeze(this);
-	}
-	existsSync(path) {
-		return existsSync(path);
-	}
-	readFileSync(path) {
-		return readFileSync(path, "utf-8");
-	}
-	writeFileSync(path, data) {
-		writeFileSync(path, data);
-	}
-	writeSecretFileSync(path, data) {
-		writeFileSync(path, data, { mode: SECRET_MODE });
-		try {
-			chmodSync(path, SECRET_MODE);
-		} catch {}
-	}
-	appendFileSync(path, data) {
-		appendFileSync(path, data);
-	}
-	unlink(path) {
-		try {
-			unlinkSync(path);
-		} catch {}
-	}
-	mkdirSync(path, options) {
-		mkdirSync(path, { recursive: options?.recursive ?? false });
-	}
-	readdirSync(path) {
-		return readdirSync(path);
-	}
-	statSync(path) {
-		const stat = statSync(path);
-		return {
-			mtimeMs: stat.mtimeMs,
-			mode: stat.mode & 511
-		};
-	}
-};
-//#endregion
 //#region lib/connectors/schedule-state-store.ts
 const defaultFs = new NodeFunnelFileSystem();
 /**
@@ -353,33 +299,4 @@ var FunnelScheduleListener = class extends FunnelConnectorListener {
 	}
 };
 //#endregion
-//#region lib/connectors/schedule-connector-schema.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.
-*/
-const scheduleCatchupPolicySchema = z.enum([
-	"latest",
-	"all",
-	"skip"
-]);
-const scheduleEntrySchema = z.object({
-	id: z.string(),
-	cron: z.string(),
-	prompt: z.string(),
-	enabled: z.boolean().default(true),
-	catchupPolicy: scheduleCatchupPolicySchema.default("latest")
-});
-const scheduleConnectorSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	type: z.literal("schedule"),
-	entries: z.array(scheduleEntrySchema).default([]),
-	createdAt: z.string().datetime().optional(),
-	updatedAt: z.string().datetime().optional()
-});
-//#endregion
-export { ScheduleStateStore as a, matchCron as c, FunnelScheduleListener as i, scheduleConnectorSchema as n, NodeFunnelFileSystem as o, scheduleEntrySchema as r, FunnelFileSystem as s, scheduleCatchupPolicySchema as t };
+export { ScheduleStateStore as n, matchCron as r, FunnelScheduleListener as t };