@interactive-inc/claude-funnel 0.8.1 → 0.10.1

package/dist/connector-adapter-CXB-q_XC.d.ts

@@ -0,0 +1,11 @@
+//#region lib/connectors/connector-adapter.d.ts
+type CallInput = {
+  method: string;
+  path: string;
+  body?: unknown;
+};
+declare abstract class FunnelConnectorAdapter {
+  abstract call(input: CallInput): Promise<unknown>;
+}
+//#endregion
+export { FunnelConnectorAdapter as n, CallInput as t };

package/dist/connector-adapter-D5Utumgz.js

@@ -0,0 +1,4 @@
+//#region lib/connectors/connector-adapter.ts
+var FunnelConnectorAdapter = class {};
+//#endregion
+export { FunnelConnectorAdapter as t };

package/dist/connectors/discord.d.ts

@@ -0,0 +1,76 @@
+import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-CXB-q_XC.js";
+import { n as discordConnectorSchema, t as DiscordConnectorConfig } from "../discord-connector-schema-Dww2I4zH.js";
+import { n as FunnelConnectorListener, r as NotifyFn, t as FunnelLogger } from "../logger-CTlXs7z4.js";
+
+//#region lib/engine/http/http-client.d.ts
+type HttpRequest = {
+  method: string;
+  url: string;
+  headers?: Record<string, string>;
+  body?: string;
+};
+type HttpResponse = {
+  status: number;
+  ok: boolean;
+  text(): Promise<string>;
+  json(): Promise<unknown>;
+};
+declare abstract class FunnelHttpClient {
+  abstract fetch(request: HttpRequest): Promise<HttpResponse>;
+}
+//#endregion
+//#region lib/connectors/discord-adapter.d.ts
+type Deps$1 = {
+  config: DiscordConnectorConfig;
+  http?: FunnelHttpClient;
+};
+declare class FunnelDiscordAdapter extends FunnelConnectorAdapter {
+  private readonly token;
+  private readonly http;
+  constructor(deps: Deps$1);
+  call(input: CallInput): Promise<unknown>;
+}
+//#endregion
+//#region lib/connectors/discord-event-processor.d.ts
+type DiscordInboundMessage = {
+  authorId: string;
+  authorIsBot: boolean;
+  channelId: string;
+  guildId: string | null;
+  mentionedUserIds: string[];
+  raw: unknown;
+};
+type DiscordProcessedSkip = {
+  skip: true;
+};
+type DiscordProcessedEmit = {
+  skip: false;
+  content: string;
+  meta: Record<string, string>;
+};
+type DiscordProcessed = DiscordProcessedSkip | DiscordProcessedEmit;
+type Props = {
+  ownUserId: string;
+};
+declare class FunnelDiscordEventProcessor {
+  private readonly ownUserId;
+  constructor(props: Props);
+  process(message: DiscordInboundMessage): DiscordProcessed;
+}
+//#endregion
+//#region lib/connectors/discord-listener.d.ts
+type Deps = {
+  config: DiscordConnectorConfig;
+  logger?: FunnelLogger;
+};
+declare class FunnelDiscordListener extends FunnelConnectorListener {
+  private readonly config;
+  private readonly logger;
+  private client;
+  constructor(deps: Deps);
+  start(notify: NotifyFn): Promise<void>;
+  stop(): Promise<void>;
+  isAlive(): boolean;
+}
+//#endregion
+export { DiscordConnectorConfig, DiscordInboundMessage, DiscordProcessed, DiscordProcessedEmit, DiscordProcessedSkip, FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelDiscordListener, discordConnectorSchema };

package/dist/connectors/discord.js

@@ -0,0 +1,2 @@
+import { i as FunnelDiscordAdapter, n as FunnelDiscordListener, r as FunnelDiscordEventProcessor, t as discordConnectorSchema } from "../discord-connector-schema-ygf5Df-2.js";
+export { FunnelDiscordAdapter, FunnelDiscordEventProcessor, FunnelDiscordListener, discordConnectorSchema };

package/dist/connectors/gh.d.ts

@@ -0,0 +1,38 @@
+import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-CXB-q_XC.js";
+import { n as FunnelConnectorListener, r as NotifyFn, t as FunnelLogger } from "../logger-CTlXs7z4.js";
+import { a as FunnelProcessRunner, n as ghConnectorSchema, t as GhConnectorConfig } from "../gh-connector-schema-BZFAS-p-.js";
+
+//#region lib/connectors/gh-adapter.d.ts
+type Deps$1 = {
+  process?: FunnelProcessRunner;
+};
+declare class FunnelGhAdapter extends FunnelConnectorAdapter {
+  private readonly process;
+  constructor(deps?: Deps$1);
+  call(input: CallInput): Promise<unknown>;
+}
+//#endregion
+//#region lib/connectors/gh-listener.d.ts
+type Deps = {
+  config: GhConnectorConfig;
+  process?: FunnelProcessRunner;
+  logger?: FunnelLogger;
+  now?: () => Date;
+};
+declare class FunnelGhListener extends FunnelConnectorListener {
+  private readonly config;
+  private readonly process;
+  private readonly logger;
+  private readonly now;
+  private readonly seen;
+  private bootstrapped;
+  private since;
+  private timer;
+  constructor(deps: Deps);
+  start(notify: NotifyFn): Promise<void>;
+  stop(): Promise<void>;
+  isAlive(): boolean;
+  pollOnce(notify: NotifyFn): Promise<void>;
+}
+//#endregion
+export { FunnelGhAdapter, FunnelGhListener, GhConnectorConfig, ghConnectorSchema };

package/dist/connectors/gh.js

@@ -0,0 +1,2 @@
+import { n as FunnelGhListener, r as FunnelGhAdapter, t as ghConnectorSchema } from "../gh-connector-schema-2ml29MBC.js";
+export { FunnelGhAdapter, FunnelGhListener, ghConnectorSchema };

package/dist/connectors/schedule.d.ts

@@ -0,0 +1,53 @@
+import { n as FunnelConnectorListener, r as NotifyFn, t as FunnelLogger } from "../logger-CTlXs7z4.js";
+import { a as ScheduleEntry, c as scheduleEntrySchema, i as ScheduleConnectorConfig, n as FunnelFileSystem, o as scheduleCatchupPolicySchema, r as ScheduleCatchupPolicy, s as scheduleConnectorSchema } from "../file-system-Co60LrmR.js";
+
+//#region lib/connectors/match-cron.d.ts
+declare const matchCron: (expr: string, date: Date) => boolean;
+//#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 Deps = {
+  config: ScheduleConnectorConfig;
+  lastFiredStore: ScheduleStateStore;
+  logger?: FunnelLogger;
+  now?: () => Date;
+};
+declare class FunnelScheduleListener extends FunnelConnectorListener {
+  private readonly config;
+  private readonly lastFiredStore;
+  private readonly logger;
+  private readonly now;
+  private timer;
+  private stopped;
+  constructor(deps: Deps);
+  start(notify: NotifyFn): Promise<void>;
+  stop(): Promise<void>;
+  isAlive(): boolean;
+  tick(notify: NotifyFn): Promise<void>;
+  private fireEntry;
+  private notifyOne;
+  private findMostRecentMatch;
+  private findAllMatches;
+  private logInvalidCron;
+  private truncateToMinute;
+}
+//#endregion
+export { FunnelScheduleListener, ScheduleCatchupPolicy, ScheduleConnectorConfig, ScheduleEntry, ScheduleStateStore, matchCron, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema };

package/dist/connectors/schedule.js

@@ -0,0 +1,2 @@
+import { a as ScheduleStateStore, c as matchCron, i as FunnelScheduleListener, n as scheduleConnectorSchema, r as scheduleEntrySchema, t as scheduleCatchupPolicySchema } from "../schedule-connector-schema-CkuIQ0JQ.js";
+export { FunnelScheduleListener, ScheduleStateStore, matchCron, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema };

package/dist/connectors/slack.d.ts

@@ -0,0 +1,34 @@
+import { n as FunnelConnectorAdapter, t as CallInput } from "../connector-adapter-CXB-q_XC.js";
+import { n as FunnelConnectorListener, r as NotifyFn, t as FunnelLogger } from "../logger-CTlXs7z4.js";
+import { a as SlackRawEvent, i as SlackProcessedSkip, n as SlackProcessed, o as SlackConnectorConfig, r as SlackProcessedEmit, s as slackConnectorSchema, t as FunnelSlackEventProcessor } from "../slack-event-processor-CS-bAit9.js";
+
+//#region lib/connectors/slack-adapter.d.ts
+type SlackWebClientLike = {
+  apiCall: (method: string, options?: Record<string, unknown>) => Promise<unknown>;
+};
+type Deps$1 = {
+  config: SlackConnectorConfig;
+  client?: SlackWebClientLike;
+};
+declare class FunnelSlackAdapter extends FunnelConnectorAdapter {
+  private readonly client;
+  constructor(deps: Deps$1);
+  call(input: CallInput): Promise<unknown>;
+}
+//#endregion
+//#region lib/connectors/slack-listener.d.ts
+type Deps = {
+  config: SlackConnectorConfig;
+  logger?: FunnelLogger;
+};
+declare class FunnelSlackListener extends FunnelConnectorListener {
+  private readonly config;
+  private readonly logger;
+  private app;
+  constructor(deps: Deps);
+  start(notify: NotifyFn): Promise<void>;
+  stop(): Promise<void>;
+  isAlive(): boolean;
+}
+//#endregion
+export { FunnelSlackAdapter, FunnelSlackEventProcessor, FunnelSlackListener, SlackConnectorConfig, SlackProcessed, SlackProcessedEmit, SlackProcessedSkip, SlackRawEvent, SlackWebClientLike, slackConnectorSchema };

package/dist/connectors/slack.js

@@ -0,0 +1,2 @@
+import { i as FunnelSlackAdapter, n as FunnelSlackListener, r as FunnelSlackEventProcessor, t as slackConnectorSchema } from "../slack-connector-schema-Cd22WiHB.js";
+export { FunnelSlackAdapter, FunnelSlackEventProcessor, FunnelSlackListener, slackConnectorSchema };

package/dist/discord-connector-schema-Dww2I4zH.d.ts

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

package/dist/discord-connector-schema-ygf5Df-2.js

@@ -0,0 +1,173 @@
+import { t as FunnelConnectorAdapter } from "./connector-adapter-D5Utumgz.js";
+import { r as FunnelConnectorListener, t as NodeFunnelLogger } from "./node-logger-DQz_BGOD.js";
+import { Client, GatewayIntentBits, Partials } from "discord.js";
+import { z } from "zod";
+//#region lib/engine/http/http-client.ts
+var FunnelHttpClient = class {};
+//#endregion
+//#region lib/engine/http/node-http-client.ts
+var NodeFunnelHttpClient = class extends FunnelHttpClient {
+	constructor() {
+		super();
+		Object.freeze(this);
+	}
+	async fetch(request) {
+		const res = await globalThis.fetch(request.url, {
+			method: request.method,
+			headers: request.headers,
+			body: request.body
+		});
+		return {
+			status: res.status,
+			ok: res.ok,
+			text: () => res.text(),
+			json: () => res.json()
+		};
+	}
+};
+//#endregion
+//#region lib/connectors/discord-adapter.ts
+const DISCORD_API_BASE = "https://discord.com/api/v10";
+const defaultHttp = new NodeFunnelHttpClient();
+var FunnelDiscordAdapter = class extends FunnelConnectorAdapter {
+	token;
+	http;
+	constructor(deps) {
+		super();
+		this.token = deps.config.botToken;
+		this.http = deps.http ?? defaultHttp;
+		Object.freeze(this);
+	}
+	async call(input) {
+		const method = (input.method || "GET").toUpperCase();
+		const path = input.path.startsWith("/") ? input.path : `/${input.path}`;
+		const body = input.body;
+		const hasBody = body !== null && typeof body === "object" && method !== "GET" && Object.keys(body).length > 0;
+		const res = await this.http.fetch({
+			method,
+			url: `${DISCORD_API_BASE}${path}`,
+			headers: {
+				Authorization: `Bot ${this.token}`,
+				"Content-Type": "application/json"
+			},
+			body: hasBody ? JSON.stringify(input.body) : void 0
+		});
+		if (!res.ok) throw new Error(`Discord API failed (${res.status}): ${await res.text()}`);
+		if (res.status === 204) return null;
+		return await res.json();
+	}
+};
+//#endregion
+//#region lib/connectors/discord-event-processor.ts
+var FunnelDiscordEventProcessor = class {
+	ownUserId;
+	constructor(props) {
+		this.ownUserId = props.ownUserId;
+	}
+	process(message) {
+		if (message.authorIsBot) return { skip: true };
+		const mentioned = this.ownUserId ? message.mentionedUserIds.includes(this.ownUserId) : false;
+		return {
+			skip: false,
+			content: JSON.stringify(message.raw),
+			meta: {
+				event_type: "discord",
+				channel_id: message.channelId,
+				user_id: message.authorId,
+				mentioned: String(mentioned),
+				guild_id: message.guildId ?? ""
+			}
+		};
+	}
+};
+//#endregion
+//#region lib/connectors/discord-listener.ts
+const defaultLogger = new NodeFunnelLogger();
+var FunnelDiscordListener = class extends FunnelConnectorListener {
+	config;
+	logger;
+	client = null;
+	constructor(deps) {
+		super();
+		this.config = deps.config;
+		this.logger = deps.logger ?? defaultLogger;
+	}
+	async start(notify) {
+		const client = new Client({
+			intents: [
+				GatewayIntentBits.Guilds,
+				GatewayIntentBits.GuildMessages,
+				GatewayIntentBits.MessageContent,
+				GatewayIntentBits.DirectMessages
+			],
+			partials: [Partials.Channel]
+		});
+		client.on("messageCreate", async (message) => {
+			const ownUserId = client.user?.id ?? "";
+			const mentionedUserIds = [...message.mentions.users.keys()];
+			this.logger.info("discord messageCreate", {
+				author: message.author.id,
+				authorIsBot: String(message.author.bot),
+				channelId: message.channelId,
+				guildId: message.guildId ?? "",
+				mentions: mentionedUserIds.join(","),
+				ownUserId,
+				mentioned: String(mentionedUserIds.includes(ownUserId))
+			});
+			const result = new FunnelDiscordEventProcessor({ ownUserId }).process({
+				authorId: message.author.id,
+				authorIsBot: message.author.bot,
+				channelId: message.channelId,
+				guildId: message.guildId,
+				mentionedUserIds,
+				raw: message.toJSON()
+			});
+			if (result.skip) {
+				this.logger.info("discord skip", { reason: "bot author" });
+				return;
+			}
+			try {
+				await notify(result.content, result.meta);
+			} catch (error) {
+				this.logger.error("discord notify error", { error: error instanceof Error ? error.message : String(error) });
+			}
+		});
+		client.on("ready", (readyClient) => {
+			this.logger.info("discord ready", {
+				userId: readyClient.user.id,
+				tag: readyClient.user.tag,
+				guilds: String(readyClient.guilds.cache.size)
+			});
+		});
+		client.on("error", (error) => {
+			this.logger.error("discord client error", { error: error instanceof Error ? error.message : String(error) });
+		});
+		await client.login(this.config.botToken);
+		this.client = client;
+	}
+	async stop() {
+		if (!this.client) return;
+		try {
+			await this.client.destroy();
+		} catch (error) {
+			this.logger.error("discord stop error", { error: error instanceof Error ? error.message : String(error) });
+		} finally {
+			this.client = null;
+		}
+	}
+	isAlive() {
+		return this.client !== null;
+	}
+};
+//#endregion
+//#region lib/connectors/discord-connector-schema.ts
+const discordConnectorSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	type: z.literal("discord"),
+	botToken: z.string().min(10),
+	createdAt: z.string().datetime().optional(),
+	updatedAt: z.string().datetime().optional()
+});
+//#endregion
+export { FunnelDiscordAdapter as i, FunnelDiscordListener as n, FunnelDiscordEventProcessor as r, discordConnectorSchema as t };

package/dist/file-system-Co60LrmR.d.ts

@@ -0,0 +1,74 @@
+import { z } from "zod";
+
+//#region lib/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
+//#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
+export { ScheduleEntry as a, scheduleEntrySchema as c, ScheduleConnectorConfig as i, FunnelFileSystem as n, scheduleCatchupPolicySchema as o, ScheduleCatchupPolicy as r, scheduleConnectorSchema as s, FileStat as t };