@interactive-inc/claude-funnel 0.8.1 → 0.10.0

package/dist/logger-CTlXs7z4.d.ts

@@ -0,0 +1,33 @@
+//#region lib/connectors/connector-listener.d.ts
+type NotifyFn = (content: string, meta?: Record<string, string>) => Promise<void>;
+/**
+ * Long-lived event source for one connector.
+ *
+ * `start()` opens the underlying connection (Slack Socket Mode, Discord
+ * Gateway, GH polling, schedule tick) and pushes events through `notify`.
+ * `stop()` releases the resources so the supervisor can recreate the listener
+ * with new config without restarting the whole gateway. `isAlive()` lets the
+ * supervisor periodically health-check and auto-restart dead listeners; the
+ * default optimistic implementation is fine for poll/tick-based listeners
+ * that self-heal.
+ */
+declare abstract class FunnelConnectorListener {
+  abstract start(notify: NotifyFn): Promise<void>;
+  abstract stop(): Promise<void>;
+  isAlive(): boolean;
+}
+//#endregion
+//#region lib/engine/logger/logger.d.ts
+/**
+ * Structured logger with three levels and an optional log-file path.
+ * Defaults to NodeFunnelLogger (appends to /tmp/funnel/funnel.log);
+ * MemoryFunnelLogger captures entries in memory and NoopFunnelLogger silences output.
+ */
+declare abstract class FunnelLogger {
+  abstract info(message: string, meta?: Record<string, unknown>): void;
+  abstract warn(message: string, meta?: Record<string, unknown>): void;
+  abstract error(message: string, meta?: Record<string, unknown>): void;
+  abstract readonly file: string | null;
+}
+//#endregion
+export { FunnelConnectorListener as n, NotifyFn as r, FunnelLogger as t };

package/dist/node-logger-DQz_BGOD.js

@@ -0,0 +1,61 @@
+import { dirname, join } from "node:path";
+import { appendFileSync, mkdirSync } from "node:fs";
+//#region lib/connectors/connector-listener.ts
+/**
+* Long-lived event source for one connector.
+*
+* `start()` opens the underlying connection (Slack Socket Mode, Discord
+* Gateway, GH polling, schedule tick) and pushes events through `notify`.
+* `stop()` releases the resources so the supervisor can recreate the listener
+* with new config without restarting the whole gateway. `isAlive()` lets the
+* supervisor periodically health-check and auto-restart dead listeners; the
+* default optimistic implementation is fine for poll/tick-based listeners
+* that self-heal.
+*/
+var FunnelConnectorListener = class {
+	isAlive() {
+		return true;
+	}
+};
+//#endregion
+//#region lib/engine/logger/logger.ts
+/**
+* Structured logger with three levels and an optional log-file path.
+* Defaults to NodeFunnelLogger (appends to /tmp/funnel/funnel.log);
+* MemoryFunnelLogger captures entries in memory and NoopFunnelLogger silences output.
+*/
+var FunnelLogger = class {};
+//#endregion
+//#region lib/engine/logger/node-logger.ts
+const DEFAULT_LOG_FILE = join("/tmp/funnel", "funnel.log");
+var NodeFunnelLogger = class extends FunnelLogger {
+	file;
+	now;
+	constructor(props = {}) {
+		super();
+		this.file = props.file ?? DEFAULT_LOG_FILE;
+		this.now = props.now ?? (() => /* @__PURE__ */ new Date());
+		Object.freeze(this);
+	}
+	info(message, meta) {
+		this.write("info", message, meta);
+	}
+	warn(message, meta) {
+		this.write("warn", message, meta);
+	}
+	error(message, meta) {
+		this.write("error", message, meta);
+	}
+	write(level, message, meta) {
+		mkdirSync(dirname(this.file), { recursive: true });
+		const entry = {
+			time: this.now().toISOString(),
+			level,
+			message,
+			...meta ? { meta } : {}
+		};
+		appendFileSync(this.file, `${JSON.stringify(entry)}\n`);
+	}
+};
+//#endregion
+export { FunnelLogger as n, FunnelConnectorListener as r, NodeFunnelLogger as t };

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

@@ -0,0 +1,325 @@
+import { r as FunnelConnectorListener, t as NodeFunnelLogger } from "./node-logger-DQz_BGOD.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();
+	for (const part of expr.split(",")) {
+		const [rangePart, stepPart] = part.split("/");
+		const step = stepPart ? Number(stepPart) : 1;
+		if (!Number.isFinite(step) || step <= 0) throw new Error(`invalid cron step: "${stepPart}"`);
+		let lo = min;
+		let hi = max;
+		if (rangePart === "*" || rangePart === void 0 || rangePart === "") {
+			lo = min;
+			hi = max;
+		} else if (rangePart.includes("-")) {
+			const [aStr, bStr] = rangePart.split("-");
+			const a = Number(aStr);
+			const b = Number(bStr);
+			if (!Number.isFinite(a) || !Number.isFinite(b)) throw new Error(`invalid cron range: "${rangePart}"`);
+			lo = a;
+			hi = b;
+		} else {
+			const n = Number(rangePart);
+			if (!Number.isFinite(n)) throw new Error(`invalid cron value: "${rangePart}"`);
+			lo = n;
+			hi = stepPart ? max : n;
+		}
+		if (lo < min || hi > max || lo > hi) throw new Error(`cron value out of range: ${rangePart} (must be ${min}-${max})`);
+		for (let i = lo; i <= hi; i += step) values.add(i);
+	}
+	return {
+		min,
+		max,
+		values
+	};
+};
+const matchCron = (expr, date) => {
+	const parts = expr.trim().split(/\s+/);
+	if (parts.length !== 5) throw new Error(`cron must have 5 fields (got ${parts.length}): "${expr}"`);
+	const [minute, hour, dom, month, dow] = parts;
+	if (!minute || !hour || !dom || !month || !dow) throw new Error(`cron has empty fields: "${expr}"`);
+	const fields = [
+		{
+			field: parseField(minute, 0, 59),
+			value: date.getMinutes()
+		},
+		{
+			field: parseField(hour, 0, 23),
+			value: date.getHours()
+		},
+		{
+			field: parseField(dom, 1, 31),
+			value: date.getDate()
+		},
+		{
+			field: parseField(month, 1, 12),
+			value: date.getMonth() + 1
+		},
+		{
+			field: parseField(dow, 0, 6),
+			value: date.getDay()
+		}
+	];
+	for (const { field, value } of fields) if (!field.values.has(value)) return false;
+	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();
+/**
+* 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).
+*/
+var ScheduleStateStore = class {
+	path;
+	fs;
+	constructor(deps) {
+		this.path = deps.path;
+		this.fs = deps.fs ?? defaultFs;
+		Object.freeze(this);
+	}
+	load() {
+		const map = /* @__PURE__ */ new Map();
+		if (!this.fs.existsSync(this.path)) return map;
+		const raw = JSON.parse(this.fs.readFileSync(this.path));
+		if (raw === null || typeof raw !== "object") return map;
+		for (const [id, iso] of Object.entries(raw)) if (typeof iso === "string") map.set(id, new Date(iso));
+		return map;
+	}
+	save(state) {
+		const obj = {};
+		for (const [id, date] of state) obj[id] = date.toISOString();
+		this.fs.mkdirSync(dirname(this.path), { recursive: true });
+		this.fs.writeFileSync(this.path, `${JSON.stringify(obj, null, 2)}\n`);
+	}
+};
+//#endregion
+//#region lib/connectors/schedule-listener.ts
+const defaultLogger = new NodeFunnelLogger();
+const MAX_CATCHUP_MINUTES = 1440;
+var FunnelScheduleListener = class extends FunnelConnectorListener {
+	config;
+	lastFiredStore;
+	logger;
+	now;
+	timer = null;
+	stopped = false;
+	constructor(deps) {
+		super();
+		this.config = deps.config;
+		this.lastFiredStore = deps.lastFiredStore;
+		this.logger = deps.logger ?? defaultLogger;
+		this.now = deps.now ?? (() => /* @__PURE__ */ new Date());
+	}
+	async start(notify) {
+		this.stopped = false;
+		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);
+				scheduleNext();
+			}, msUntilNextMinute);
+			this.timer.unref();
+		};
+		await this.tick(notify);
+		scheduleNext();
+	}
+	async stop() {
+		this.stopped = true;
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = null;
+		}
+	}
+	isAlive() {
+		return !this.stopped && this.timer !== null;
+	}
+	async tick(notify) {
+		const now = this.truncateToMinute(this.now());
+		const state = this.lastFiredStore.load();
+		let changed = false;
+		for (const entry of this.config.entries) {
+			if (!entry.enabled) continue;
+			if (await this.fireEntry(entry, now, state, notify)) changed = true;
+		}
+		if (changed) this.lastFiredStore.save(state);
+	}
+	async fireEntry(entry, now, state, notify) {
+		const lastFired = state.get(entry.id);
+		const searchFrom = lastFired ? new Date(lastFired.getTime() + 6e4) : now;
+		if (searchFrom.getTime() > now.getTime()) return false;
+		if (entry.catchupPolicy === "skip") {
+			try {
+				if (!matchCron(entry.cron, now)) return false;
+			} catch (error) {
+				this.logInvalidCron(entry, error);
+				return false;
+			}
+			await this.notifyOne(entry, now, notify, false);
+			state.set(entry.id, now);
+			return true;
+		}
+		if (entry.catchupPolicy === "all") {
+			const matches = this.findAllMatches(entry.cron, searchFrom, now, entry.id);
+			if (matches.length === 0) return false;
+			for (const match of matches) await this.notifyOne(entry, match, notify, match.getTime() !== now.getTime());
+			state.set(entry.id, matches[matches.length - 1] ?? now);
+			return true;
+		}
+		const match = this.findMostRecentMatch(entry.cron, searchFrom, now, entry.id);
+		if (!match) return false;
+		await this.notifyOne(entry, match, notify, match.getTime() !== now.getTime());
+		state.set(entry.id, match);
+		return true;
+	}
+	async notifyOne(entry, firedAt, notify, catchup) {
+		const meta = {
+			event_type: "schedule",
+			schedule_id: entry.id,
+			cron: entry.cron,
+			fired_at: firedAt.toISOString(),
+			catchup_policy: entry.catchupPolicy
+		};
+		if (catchup) meta.catchup = "true";
+		await notify(entry.prompt, meta);
+	}
+	findMostRecentMatch(cron, from, until, entryId) {
+		const maxIterations = Math.min(MAX_CATCHUP_MINUTES, Math.floor((until.getTime() - from.getTime()) / 6e4) + 1);
+		for (let i = 0; i < maxIterations; i++) {
+			const candidate = /* @__PURE__ */ new Date(until.getTime() - i * 6e4);
+			try {
+				if (matchCron(cron, candidate)) return candidate;
+			} catch (error) {
+				this.logInvalidCron({
+					id: entryId,
+					cron
+				}, error);
+				return null;
+			}
+		}
+		return null;
+	}
+	findAllMatches(cron, from, until, entryId) {
+		const maxIterations = Math.min(MAX_CATCHUP_MINUTES, Math.floor((until.getTime() - from.getTime()) / 6e4) + 1);
+		const matches = [];
+		for (let i = 0; i < maxIterations; i++) {
+			const candidate = new Date(from.getTime() + i * 6e4);
+			if (candidate.getTime() > until.getTime()) break;
+			try {
+				if (matchCron(cron, candidate)) matches.push(candidate);
+			} catch (error) {
+				this.logInvalidCron({
+					id: entryId,
+					cron
+				}, error);
+				return [];
+			}
+		}
+		return matches;
+	}
+	logInvalidCron(entry, error) {
+		this.logger.error("invalid cron expression in schedule", {
+			connector: this.config.name,
+			id: entry.id,
+			cron: entry.cron,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+	truncateToMinute(date) {
+		const copy = new Date(date.getTime());
+		copy.setSeconds(0, 0);
+		return copy;
+	}
+};
+//#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 };

package/dist/slack-connector-schema-Cd22WiHB.js

@@ -0,0 +1,153 @@
+import { t as FunnelConnectorAdapter } from "./connector-adapter-D5Utumgz.js";
+import { r as FunnelConnectorListener, t as NodeFunnelLogger } from "./node-logger-DQz_BGOD.js";
+import { z } from "zod";
+import { WebClient } from "@slack/web-api";
+import { App, LogLevel } from "@slack/bolt";
+//#region lib/connectors/slack-adapter.ts
+const toRecord = (value) => {
+	const result = {};
+	for (const [key, val] of Object.entries(value)) result[key] = val;
+	return result;
+};
+var FunnelSlackAdapter = class extends FunnelConnectorAdapter {
+	client;
+	constructor(deps) {
+		super();
+		this.client = deps.client ?? new WebClient(deps.config.botToken);
+		Object.freeze(this);
+	}
+	async call(input) {
+		const body = input.body !== null && typeof input.body === "object" ? toRecord(input.body) : {};
+		return await this.client.apiCall(input.path, body);
+	}
+};
+//#endregion
+//#region lib/connectors/slack-event-processor.ts
+const ALLOWED_EVENTS = new Set(["message", "app_mention"]);
+const ALLOWED_SUBTYPES = new Set([
+	void 0,
+	"thread_broadcast",
+	"bot_message",
+	"file_share"
+]);
+const DEDUP_WINDOW = 1e4;
+const getString = (event, key) => {
+	const value = event[key];
+	return typeof value === "string" ? value : void 0;
+};
+var FunnelSlackEventProcessor = class {
+	ownBotUserId;
+	ownBotId;
+	now;
+	dedup = /* @__PURE__ */ new Map();
+	constructor(props) {
+		this.ownBotUserId = props.ownBotUserId;
+		this.ownBotId = props.ownBotId;
+		this.now = props.now ?? (() => Date.now());
+	}
+	process(event) {
+		const eventType = getString(event, "type");
+		if (!eventType || !ALLOWED_EVENTS.has(eventType)) return { skip: true };
+		const subtype = getString(event, "subtype");
+		if (!ALLOWED_SUBTYPES.has(subtype)) return { skip: true };
+		const channelId = getString(event, "channel") ?? "";
+		const dedupKey = `${channelId}:${getString(event, "event_ts") ?? getString(event, "ts") ?? ""}`;
+		const now = this.now();
+		if (this.dedup.has(dedupKey)) return { skip: true };
+		this.dedup.set(dedupKey, now);
+		for (const key of this.dedup.keys()) if ((this.dedup.get(key) ?? 0) < now - DEDUP_WINDOW) this.dedup.delete(key);
+		const userId = getString(event, "user");
+		const botId = getString(event, "bot_id");
+		if (userId === this.ownBotUserId) return { skip: true };
+		if (botId === this.ownBotId) return { skip: true };
+		const mentioned = (getString(event, "text") ?? "").includes(`<@${this.ownBotUserId}>`);
+		const threadTs = getString(event, "thread_ts") ?? getString(event, "ts") ?? "";
+		return {
+			skip: false,
+			content: JSON.stringify(event),
+			meta: {
+				event_type: "slack",
+				channel_id: channelId,
+				user_id: userId ?? "",
+				mentioned: String(mentioned),
+				thread_ts: threadTs
+			},
+			shouldReact: mentioned,
+			channel: channelId,
+			timestamp: getString(event, "ts") ?? ""
+		};
+	}
+};
+//#endregion
+//#region lib/connectors/slack-listener.ts
+const middlewareArgsSchema = z.object({ event: z.record(z.string(), z.unknown()).optional() });
+const defaultLogger = new NodeFunnelLogger();
+var FunnelSlackListener = class extends FunnelConnectorListener {
+	config;
+	logger;
+	app = null;
+	constructor(deps) {
+		super();
+		this.config = deps.config;
+		this.logger = deps.logger ?? defaultLogger;
+	}
+	async start(notify) {
+		const app = new App({
+			token: this.config.botToken,
+			appToken: this.config.appToken,
+			socketMode: true,
+			logLevel: LogLevel.ERROR
+		});
+		const authResult = await app.client.auth.test({ token: this.config.botToken });
+		const processor = new FunnelSlackEventProcessor({
+			ownBotUserId: authResult.user_id ?? "",
+			ownBotId: authResult.bot_id ?? ""
+		});
+		app.use(async (args) => {
+			const parsed = middlewareArgsSchema.safeParse(args);
+			if (!parsed.success || !parsed.data.event) return;
+			const result = processor.process(parsed.data.event);
+			if (result.skip) return;
+			if (result.shouldReact) try {
+				await app.client.reactions.add({
+					token: this.config.botToken,
+					channel: result.channel,
+					timestamp: result.timestamp,
+					name: "eyes"
+				});
+			} catch {}
+			await notify(result.content, result.meta);
+		});
+		app.error(async (error) => {
+			this.logger.error("Slack error", { error: error instanceof Error ? error.message : String(error) });
+		});
+		await app.start();
+		this.app = app;
+	}
+	async stop() {
+		if (!this.app) return;
+		try {
+			await this.app.stop();
+		} catch (error) {
+			this.logger.error("Slack stop error", { error: error instanceof Error ? error.message : String(error) });
+		} finally {
+			this.app = null;
+		}
+	}
+	isAlive() {
+		return this.app !== null;
+	}
+};
+//#endregion
+//#region lib/connectors/slack-connector-schema.ts
+const slackConnectorSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	type: z.literal("slack"),
+	botToken: z.string().startsWith("xoxb-"),
+	appToken: z.string().startsWith("xapp-"),
+	createdAt: z.string().datetime().optional(),
+	updatedAt: z.string().datetime().optional()
+});
+//#endregion
+export { FunnelSlackAdapter as i, FunnelSlackListener as n, FunnelSlackEventProcessor as r, slackConnectorSchema as t };

package/dist/slack-connector-schema-D7zAHN8k.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+
+//#region lib/connectors/slack-connector-schema.d.ts
+declare const slackConnectorSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"slack">;
+  botToken: z.ZodString;
+  appToken: z.ZodString;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SlackConnectorConfig = z.infer<typeof slackConnectorSchema>;
+//#endregion
+export { slackConnectorSchema as n, SlackConnectorConfig as t };

package/lib/bin.ts

@@ -1,78 +1,3 @@
 #!/usr/bin/env bun
-import pkg from "../package.json" with { type: "json" }
-import { startChannelServer } from "@/engine/mcp/channel-server"
-import { toRequest } from "@/cli/router/to-request"
-import { launchTui } from "@/tui/tui"
-import { app } from "@/cli/routes"
-import { Funnel } from "@/funnel"
 
-process.title = "funnel"
-
-const HELP = `funnel — Open Claude Funnel
-
-usage: funnel [command]
-
-commands:
-  (none)                launch TUI
-  claude                launch Claude Code (default profile or --profile)
-  channels              manage subscription boxes (and their nested connectors)
-  profiles              manage launch profiles
-  gateway               manage the gateway daemon (HTTP + WS)
-  status                show overall connection status
-  update                update funnel to the latest version
-  mcp                   run as an MCP server (invoked from .mcp.json)
-
-options:
-  --help, -h            show help
-  --version, -v         show version
-
-more: funnel <command> --help`
-
-const args = process.argv.slice(2)
-
-if (args.length === 0) {
-  await launchTui(new Funnel())
-  process.exit(0)
-}
-
-if (args[0] === "--version" || args[0] === "-v") {
-  process.stdout.write(`${pkg.version}\n`)
-  process.exit(0)
-}
-
-if (args[0] === "mcp") {
-  await startChannelServer()
-} else {
-  const { method, url } = toRequest(args)
-  const parsed = new URL(url)
-  const wantsHelp = parsed.searchParams.has("help")
-
-  if (wantsHelp && parsed.pathname === "/") {
-    process.stdout.write(`${HELP}\n`)
-    process.exit(0)
-  }
-
-  const res = await app.request(url, { method })
-
-  if (res.ok) {
-    const body = await res.text()
-    if (body) process.stdout.write(`${body}\n`)
-    process.exit(0)
-  }
-
-  if (wantsHelp) {
-    const segments = parsed.pathname.split("/").filter(Boolean)
-    const group = segments[0]
-    const fallback = group
-      ? await app.request(`http://localhost/${group}?help=true`, { method: "GET" })
-      : null
-
-    const text = fallback?.ok ? await fallback.text() : HELP
-    process.stdout.write(`${text}\n`)
-    process.exit(0)
-  }
-
-  const text = await res.text()
-  if (text) process.stderr.write(`${text}\n`)
-  process.exit(1)
-}
+import "@/cli"