@interactive-inc/flume 0.1.0 → 0.2.0

package/dist/discord.js

@@ -1,2 +1,537 @@
-import { t as FlumeDiscordSource } from "./discord-source-Q4JRIbNs.js";
-export { FlumeDiscordSource };
+import { n as createFlumeDefaultDeps, t as FlumeLogger } from "./logger-CpGB9WO_.js";
+import { a as FlumeConnectionError, i as FlumeParseError, n as FlumeReconnector, r as resolveFlumeReconnectConfig, t as scheduleFlumeReconnect } from "./schedule-reconnect-DSxZJG3h.js";
+import { t as FlumeSerialQueue } from "./serial-queue-ExmlnpzQ.js";
+import { n as isRecord, t as safeJsonParse } from "./safe-json-parse-WCg_x1JS.js";
+import { z } from "zod/v4";
+//#region lib/discord/extract-discord-meta.ts
+function extractDiscordMeta(eventName, eventData) {
+	const meta = { event_type: eventName };
+	if (typeof eventData.channel_id === "string") meta.channel_id = eventData.channel_id;
+	if (typeof eventData.guild_id === "string") meta.guild_id = eventData.guild_id;
+	if (isRecord(eventData.author) && typeof eventData.author.id === "string") meta.user_id = eventData.author.id;
+	return meta;
+}
+//#endregion
+//#region lib/discord/discord-heartbeat.ts
+var FlumeDiscordHeartbeat = class {
+	props;
+	timer = null;
+	ackReceived = true;
+	constructor(props) {
+		this.props = props;
+	}
+	start(intervalMs) {
+		this.stop();
+		this.ackReceived = true;
+		this.timer = this.props.deps.setInterval(() => {
+			if (!this.ackReceived) {
+				this.props.onZombie();
+				return;
+			}
+			this.ackReceived = false;
+			this.props.onSend();
+		}, intervalMs);
+	}
+	stop() {
+		if (this.timer === null) return;
+		this.props.deps.clearInterval(this.timer);
+		this.timer = null;
+	}
+	ack() {
+		this.ackReceived = true;
+	}
+	isRunning() {
+		return this.timer !== null;
+	}
+};
+//#endregion
+//#region lib/discord/discord-gateway-session.ts
+var FlumeDiscordGatewaySession = class FlumeDiscordGatewaySession {
+	sessionId;
+	resumeUrl;
+	seq;
+	constructor(props) {
+		this.sessionId = props.sessionId;
+		this.resumeUrl = props.resumeUrl;
+		this.seq = props.seq;
+		Object.freeze(this);
+	}
+	static empty() {
+		return new FlumeDiscordGatewaySession({
+			sessionId: null,
+			resumeUrl: null,
+			seq: null
+		});
+	}
+	canResume() {
+		return this.sessionId !== null;
+	}
+	withSeq(seq) {
+		return new FlumeDiscordGatewaySession({
+			sessionId: this.sessionId,
+			resumeUrl: this.resumeUrl,
+			seq
+		});
+	}
+	withReady(sessionId, resumeUrl) {
+		return new FlumeDiscordGatewaySession({
+			sessionId,
+			resumeUrl,
+			seq: this.seq
+		});
+	}
+	withReset() {
+		return FlumeDiscordGatewaySession.empty();
+	}
+};
+//#endregion
+//#region lib/discord/discord-gateway-message-schema.ts
+const FlumeGatewayMessageSchema = z.object({
+	op: z.number(),
+	d: z.record(z.string(), z.unknown()).nullable(),
+	s: z.number().nullable(),
+	t: z.string().nullable()
+});
+//#endregion
+//#region lib/discord/parse-discord-gateway-message.ts
+function parseDiscordGatewayMessage(raw) {
+	const json = safeJsonParse(raw);
+	const parsed = FlumeGatewayMessageSchema.safeParse(json);
+	if (!parsed.success) return new FlumeParseError(`invalid gateway message: ${raw.slice(0, 200)}`);
+	return parsed.data;
+}
+//#endregion
+//#region lib/discord/discord-gateway.ts
+const GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
+function framePreview(raw) {
+	return raw.length > 200 ? `${raw.slice(0, 200)}... (${raw.length} bytes)` : raw;
+}
+const OP_DISPATCH = 0;
+const OP_HEARTBEAT = 1;
+const OP_IDENTIFY = 2;
+const OP_RESUME = 6;
+const OP_RECONNECT = 7;
+const OP_INVALID_SESSION = 9;
+const OP_HELLO = 10;
+const OP_HEARTBEAT_ACK = 11;
+const OP_NAMES = {
+	[OP_DISPATCH]: "DISPATCH",
+	[OP_HEARTBEAT]: "HEARTBEAT",
+	[OP_IDENTIFY]: "IDENTIFY",
+	[OP_RESUME]: "RESUME",
+	[OP_RECONNECT]: "RECONNECT",
+	[OP_INVALID_SESSION]: "INVALID_SESSION",
+	[OP_HELLO]: "HELLO",
+	[OP_HEARTBEAT_ACK]: "HEARTBEAT_ACK"
+};
+var FlumeDiscordGateway = class {
+	props;
+	log;
+	ws = null;
+	heartbeat = null;
+	session = FlumeDiscordGatewaySession.empty();
+	stopped = false;
+	pendingResolve = null;
+	pendingResolved = false;
+	constructor(props) {
+		this.props = props;
+		this.log = new FlumeLogger({
+			source: "discord.gateway",
+			handler: props.onLog,
+			deps: props.deps
+		});
+	}
+	connect(url) {
+		const target = url ?? GATEWAY_URL;
+		this.log.info({
+			action: "connect.start",
+			message: `url=${new URL(target).hostname}`
+		});
+		this.pendingResolved = false;
+		return new Promise((resolve) => {
+			this.pendingResolve = resolve;
+			const socket = new this.props.deps.WebSocket(target);
+			this.ws = socket;
+			socket.addEventListener("message", (ev) => this.onMessage(String(ev.data), socket));
+			socket.addEventListener("close", (ev) => this.onClose(ev));
+			socket.addEventListener("error", () => this.onError());
+		});
+	}
+	disconnect() {
+		this.log.info({
+			action: "disconnect",
+			message: "shutting down gateway"
+		});
+		this.stopped = true;
+		this.heartbeat?.stop();
+		if (this.ws) {
+			this.ws.close(1e3, "shutdown");
+			this.ws = null;
+		}
+	}
+	isConnected() {
+		return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+	}
+	completeConnect(error) {
+		if (this.pendingResolved || !this.pendingResolve) return;
+		this.pendingResolved = true;
+		this.pendingResolve(error);
+	}
+	onMessage(raw, socket) {
+		this.log.debug({
+			action: "ws.recv",
+			message: framePreview(raw)
+		});
+		const parsed = parseDiscordGatewayMessage(raw);
+		if (parsed instanceof FlumeParseError) {
+			this.log.error({
+				action: "ws.parse-error",
+				message: parsed.message,
+				error: parsed
+			});
+			return;
+		}
+		this.log.debug({
+			action: "ws.frame",
+			message: `op=${OP_NAMES[parsed.op] ?? parsed.op} t=${parsed.t ?? "-"} s=${parsed.s ?? "-"}`,
+			detail: {
+				op: parsed.op,
+				t: parsed.t,
+				s: parsed.s
+			}
+		});
+		if (parsed.s !== null) this.session = this.session.withSeq(parsed.s);
+		if (parsed.op === OP_HELLO) return this.onHello(parsed);
+		if (parsed.op === OP_HEARTBEAT_ACK) return this.onHeartbeatAck();
+		if (parsed.op === OP_HEARTBEAT) return this.onHeartbeatRequest();
+		if (parsed.op === OP_RECONNECT) return this.onReconnectRequest(socket);
+		if (parsed.op === OP_INVALID_SESSION) return this.onInvalidSession(parsed, socket);
+		if (parsed.op === OP_DISPATCH) return this.onDispatch(parsed);
+		this.log.warn({
+			action: "ws.unknown-op",
+			message: `unknown op=${parsed.op}`,
+			detail: { op: parsed.op }
+		});
+	}
+	onHello(msg) {
+		const interval = typeof msg.d?.heartbeat_interval === "number" ? msg.d.heartbeat_interval : 0;
+		this.log.info({
+			action: "hello",
+			message: `heartbeat_interval=${interval}ms`
+		});
+		this.heartbeat = new FlumeDiscordHeartbeat({
+			deps: this.props.deps,
+			onSend: () => {
+				this.log.debug({
+					action: "heartbeat.send",
+					message: `seq=${this.session.seq}`
+				});
+				this.send({
+					op: OP_HEARTBEAT,
+					d: this.session.seq
+				});
+			},
+			onZombie: () => {
+				this.log.warn({
+					action: "heartbeat.zombie",
+					message: "no ACK received, closing connection"
+				});
+				this.ws?.close(4009, "zombie connection");
+			}
+		});
+		this.heartbeat.start(interval);
+		if (this.session.canResume()) this.sendResume();
+		else this.sendIdentify();
+	}
+	onHeartbeatAck() {
+		this.log.debug({
+			action: "heartbeat.ack",
+			message: "received"
+		});
+		this.heartbeat?.ack();
+	}
+	onHeartbeatRequest() {
+		this.log.debug({
+			action: "heartbeat.requested",
+			message: "server requested heartbeat"
+		});
+		this.send({
+			op: OP_HEARTBEAT,
+			d: this.session.seq
+		});
+	}
+	onReconnectRequest(socket) {
+		this.log.info({
+			action: "reconnect.requested",
+			message: "server requested reconnect"
+		});
+		socket.close(4e3, "reconnect requested");
+	}
+	onInvalidSession(msg, socket) {
+		const resumable = !!msg.d;
+		this.log.warn({
+			action: "invalid-session",
+			message: `resumable=${resumable}`
+		});
+		this.session = this.session.withReset();
+		if (resumable) {
+			const delay = 1e3 + this.props.deps.random() * 4e3;
+			this.log.info({
+				action: "identify.delayed",
+				message: `re-identify in ${Math.round(delay)}ms`
+			});
+			this.props.deps.setTimeout(() => this.sendIdentify(), delay);
+		} else socket.close(4e3, "invalid session");
+	}
+	onDispatch(msg) {
+		if (msg.t === "READY" && msg.d) {
+			const sessionId = typeof msg.d.session_id === "string" ? msg.d.session_id : "";
+			const resumeUrl = typeof msg.d.resume_gateway_url === "string" ? msg.d.resume_gateway_url : "";
+			this.session = this.session.withReady(sessionId, resumeUrl);
+			this.log.info({
+				action: "ready",
+				message: `session=${sessionId}`
+			});
+			this.props.onStatus("connected");
+			this.completeConnect(null);
+		}
+		if (msg.t === "RESUMED") {
+			this.log.info({
+				action: "resumed",
+				message: `session=${this.session.sessionId} seq=${this.session.seq}`
+			});
+			this.props.onStatus("connected");
+			this.completeConnect(null);
+		}
+		if (msg.t && msg.d) this.props.onDispatch(msg.t, msg.d);
+		else if (msg.t) this.props.onDispatch(msg.t, {});
+	}
+	onClose(ev) {
+		this.log.info({
+			action: "ws.close",
+			message: `code=${ev.code} reason=${ev.reason || "none"}`,
+			detail: {
+				code: ev.code,
+				reason: ev.reason
+			}
+		});
+		this.ws = null;
+		this.heartbeat?.stop();
+		this.props.onStatus("disconnected");
+		this.completeConnect(new FlumeConnectionError(`WebSocket closed before ready (code=${ev.code})`));
+	}
+	onError() {
+		this.log.error({
+			action: "ws.error",
+			message: "WebSocket error event"
+		});
+		this.completeConnect(new FlumeConnectionError("WebSocket connection error"));
+	}
+	send(input) {
+		const payload = JSON.stringify({
+			op: input.op,
+			d: input.d ?? null
+		});
+		this.log.debug({
+			action: "ws.send",
+			message: `op=${OP_NAMES[input.op] ?? input.op}`,
+			detail: { op: input.op }
+		});
+		this.ws?.send(payload);
+		this.log.debug({
+			action: "ws.sent",
+			message: framePreview(payload)
+		});
+	}
+	sendIdentify() {
+		this.log.info({
+			action: "identify",
+			message: `intents=${this.props.intents}`
+		});
+		this.send({
+			op: OP_IDENTIFY,
+			d: {
+				token: this.props.token,
+				intents: this.props.intents,
+				properties: {
+					os: "linux",
+					browser: "open-flume",
+					device: "open-flume"
+				}
+			}
+		});
+	}
+	sendResume() {
+		this.log.info({
+			action: "resume",
+			message: `session=${this.session.sessionId} seq=${this.session.seq}`
+		});
+		this.send({
+			op: OP_RESUME,
+			d: {
+				token: this.props.token,
+				session_id: this.session.sessionId,
+				seq: this.session.seq
+			}
+		});
+	}
+};
+//#endregion
+//#region lib/discord/discord-gateway-intents.ts
+const FlumeDiscordGatewayIntents = {
+	Guilds: 1,
+	GuildMembers: 2,
+	GuildModeration: 4,
+	GuildExpressions: 8,
+	GuildIntegrations: 16,
+	GuildWebhooks: 32,
+	GuildInvites: 64,
+	GuildVoiceStates: 128,
+	GuildPresences: 256,
+	GuildMessages: 512,
+	GuildMessageReactions: 1024,
+	GuildMessageTyping: 2048,
+	DirectMessages: 4096,
+	DirectMessageReactions: 8192,
+	DirectMessageTyping: 16384,
+	MessageContent: 32768,
+	GuildScheduledEvents: 65536,
+	AutoModerationConfiguration: 1 << 20,
+	AutoModerationExecution: 1 << 21,
+	GuildMessagePolls: 1 << 24,
+	DirectMessagePolls: 1 << 25
+};
+//#endregion
+//#region lib/discord/discord-source.ts
+const DEFAULT_INTENTS = FlumeDiscordGatewayIntents.Guilds | FlumeDiscordGatewayIntents.GuildMessages | FlumeDiscordGatewayIntents.DirectMessages | FlumeDiscordGatewayIntents.MessageContent;
+var FlumeDiscordSource = class {
+	options;
+	name = "discord";
+	gateway = null;
+	reconnector = null;
+	handler = null;
+	currentStatus = "disconnected";
+	log;
+	deps;
+	queue = new FlumeSerialQueue();
+	constructor(options) {
+		this.options = options;
+		this.deps = options.deps ?? createFlumeDefaultDeps();
+		this.log = new FlumeLogger({
+			source: "discord",
+			handler: options.onLog,
+			deps: this.deps
+		});
+		const rc = resolveFlumeReconnectConfig(options.reconnect);
+		if (rc) this.reconnector = new FlumeReconnector({
+			...rc,
+			deps: this.deps
+		});
+	}
+	async start(handler) {
+		if (this.options.signal?.aborted) return /* @__PURE__ */ new Error("Discord source: signal already aborted");
+		this.options.signal?.addEventListener("abort", () => this.stop(), { once: true });
+		this.handler = handler;
+		this.log.info({
+			action: "start",
+			message: "starting Discord source"
+		});
+		return this.connectInternal();
+	}
+	async stop() {
+		this.log.info({
+			action: "stop",
+			message: "stopping Discord source"
+		});
+		if (this.reconnector && !this.reconnector.aborted) this.log.debug({
+			action: "reconnect.cancel",
+			message: "aborting reconnector"
+		});
+		this.reconnector?.cancel();
+		this.gateway?.disconnect();
+		this.gateway = null;
+		this.handler = null;
+		await this.queue.drain();
+		this.setStatus("disconnected");
+	}
+	status() {
+		return this.currentStatus;
+	}
+	async connectInternal(resumeUrl) {
+		this.setStatus("connecting");
+		this.gateway = new FlumeDiscordGateway({
+			token: this.options.token,
+			intents: this.options.intents ?? DEFAULT_INTENTS,
+			onLog: this.options.onLog,
+			deps: this.deps,
+			onDispatch: (eventName, eventData) => this.handleDispatch(eventName, eventData),
+			onStatus: (status) => this.handleGatewayStatus(status)
+		});
+		const error = await this.gateway.connect(resumeUrl);
+		if (error instanceof FlumeConnectionError) {
+			this.log.error({
+				action: "connect.failed",
+				message: error.message,
+				error
+			});
+			if (!this.reconnector || this.reconnector.aborted) {
+				this.setStatus("disconnected");
+				return error;
+			}
+			this.scheduleReconnect();
+		}
+	}
+	handleDispatch(eventName, eventData) {
+		const event = {
+			source: "discord",
+			type: eventName,
+			data: eventData,
+			meta: extractDiscordMeta(eventName, eventData),
+			receivedAt: this.deps.now()
+		};
+		this.queue.add(async () => {
+			try {
+				await this.handler?.(event);
+			} catch (err) {
+				this.log.error({
+					action: "handler.error",
+					message: "user handler threw",
+					error: err instanceof Error ? err : new Error(String(err))
+				});
+			}
+		});
+	}
+	handleGatewayStatus(status) {
+		if (status === "connected") {
+			if (this.reconnector && this.reconnector.attempt > 0) this.log.info({
+				action: "reconnect.reset",
+				message: `cleared ${this.reconnector.attempt} attempts`
+			});
+			this.reconnector?.reset();
+			this.setStatus("connected");
+		}
+		if (status === "disconnected" && !this.gateway?.stopped) this.scheduleReconnect();
+	}
+	scheduleReconnect() {
+		const url = this.gateway?.session.resumeUrl ?? void 0;
+		scheduleFlumeReconnect({
+			reconnector: this.reconnector,
+			log: this.log,
+			setStatus: (status) => this.setStatus(status),
+			retry: () => {
+				this.connectInternal(url);
+			}
+		});
+	}
+	setStatus(next) {
+		if (this.currentStatus === next) return;
+		this.log.info({
+			action: "status",
+			message: `${this.currentStatus} → ${next}`
+		});
+		this.currentStatus = next;
+		this.options.onStatus?.(next);
+	}
+};
+//#endregion
+export { FlumeDiscordGateway, FlumeDiscordGatewayIntents, FlumeDiscordGatewaySession, FlumeDiscordHeartbeat, FlumeDiscordSource, FlumeGatewayMessageSchema, extractDiscordMeta, parseDiscordGatewayMessage };

package/dist/github.d.ts

@@ -1,19 +1,65 @@
-import { a as FlumeGitHubSourceOptions, i as FlumeGitHubNotification, o as FlumeHandler, y as FlumeStatus } from "./types-BVQSU336.js";
+import { E as FlumeGitHubNotificationSchema, a as FlumeGitHubSourceOptions, c as FlumeLogHandler, i as FlumeGitHubNotification, o as FlumeHandler, p as FlumeRuntimeDeps, x as FlumeStatus } from "./types-tnOPBc1p.js";
 
 //#region lib/github/github-source.d.ts
 declare class FlumeGitHubSource {
   private readonly options;
+  readonly name: "github";
   private poller;
   private currentStatus;
   private readonly log;
   private readonly deps;
+  private readonly queue;
   constructor(options: FlumeGitHubSourceOptions);
-  start(handler: FlumeHandler): Promise<void>;
+  start(handler: FlumeHandler): Promise<void | Error>;
   stop(): Promise<void>;
   status(): FlumeStatus;
   private handleNotifications;
   private setStatus;
-  static extractMeta(notification: FlumeGitHubNotification): Record<string, string>;
 }
 //#endregion
-export { FlumeGitHubSource };
+//#region lib/github/extract-github-meta.d.ts
+declare function extractGitHubMeta(notification: FlumeGitHubNotification): Record<string, string>;
+//#endregion
+//#region lib/github/github-poller.d.ts
+type Deps = Pick<FlumeRuntimeDeps, "fetch" | "setInterval" | "clearInterval" | "now">;
+type Props$1 = {
+  token: string;
+  interval: number;
+  onNotifications: (notifications: FlumeGitHubNotification[]) => void;
+  onConnected: () => void;
+  onDisconnected: (detail: string) => void;
+  onLog?: FlumeLogHandler;
+  deps: Deps;
+};
+declare class FlumeGitHubPoller {
+  private readonly props;
+  private readonly log;
+  private readonly cache;
+  private timer;
+  private since;
+  private bootstrapped;
+  stopped: boolean;
+  private consecutiveErrors;
+  constructor(props: Props$1);
+  start(): Promise<void>;
+  stop(): void;
+  private poll;
+  private processNotifications;
+  private safeFetch;
+}
+//#endregion
+//#region lib/github/github-seen-cache.d.ts
+type Props = {
+  maxSize: number;
+};
+declare class FlumeGitHubSeenCache {
+  private readonly props;
+  private seen;
+  constructor(props: Props);
+  has(id: string, updatedAt: string): boolean;
+  add(id: string, updatedAt: string): void;
+  trim(): void;
+  get size(): number;
+}
+//#endregion
+export { FlumeGitHubNotificationSchema, FlumeGitHubPoller, FlumeGitHubSeenCache, FlumeGitHubSource, extractGitHubMeta };