@interactive-inc/flume 0.1.0

package/dist/discord-source-Q4JRIbNs.js

@@ -0,0 +1,525 @@
+import { n as FlumeGatewayMessageSchema, t as FlumeLogger } from "./logger-B9E8zvgj.js";
+import { a as FlumeParseError, i as resolveFlumeReconnectConfig, n as isRecord, o as FlumeConnectionError, r as FlumeReconnector, t as safeJsonParse } from "./safe-json-parse-D8t_4Vm_.js";
+//#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/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 FlumeDiscordSource {
+	options;
+	gateway = null;
+	reconnector = null;
+	handler = null;
+	currentStatus = "disconnected";
+	log;
+	deps;
+	constructor(options) {
+		this.options = options;
+		this.deps = options.deps;
+		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;
+		this.options.signal?.addEventListener("abort", () => this.stop(), { once: true });
+		this.handler = handler;
+		this.log.info({
+			action: "start",
+			message: "starting Discord source"
+		});
+		await 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;
+		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
+			});
+			this.scheduleReconnect();
+		}
+	}
+	handleDispatch(eventName, eventData) {
+		const event = {
+			source: "discord",
+			type: eventName,
+			data: eventData,
+			meta: FlumeDiscordSource.extractMeta(eventName, eventData),
+			receivedAt: this.deps.now()
+		};
+		try {
+			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() {
+		if (!this.reconnector || this.reconnector.aborted) {
+			this.setStatus("disconnected");
+			return;
+		}
+		const url = this.gateway?.session.resumeUrl ?? void 0;
+		this.setStatus("reconnecting");
+		const delay = this.reconnector.schedule(() => {
+			this.connectInternal(url);
+		});
+		if (delay === -1) {
+			this.log.error({
+				action: "reconnect.exhausted",
+				message: `gave up after ${this.reconnector.attempt} attempts`
+			});
+			this.setStatus("disconnected");
+		} else this.log.info({
+			action: "reconnect.scheduled",
+			message: `next attempt in ${Math.round(delay)}ms`
+		});
+	}
+	setStatus(next) {
+		if (this.currentStatus === next) return;
+		this.log.info({
+			action: "status",
+			message: `${this.currentStatus} → ${next}`
+		});
+		this.currentStatus = next;
+		this.options.onStatus?.(next);
+	}
+	static extractMeta(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
+export { FlumeDiscordGatewaySession as a, parseDiscordGatewayMessage as i, FlumeDiscordGatewayIntents as n, FlumeDiscordHeartbeat as o, FlumeDiscordGateway as r, FlumeDiscordSource as t };

package/dist/discord.d.ts

@@ -0,0 +1,24 @@
+import { o as FlumeHandler, t as FlumeDiscordSourceOptions, y as FlumeStatus } from "./types-BVQSU336.js";
+
+//#region lib/discord/discord-source.d.ts
+declare class FlumeDiscordSource {
+  private readonly options;
+  private gateway;
+  private reconnector;
+  private handler;
+  private currentStatus;
+  private readonly log;
+  private readonly deps;
+  constructor(options: FlumeDiscordSourceOptions);
+  start(handler: FlumeHandler): Promise<void>;
+  stop(): Promise<void>;
+  status(): FlumeStatus;
+  private connectInternal;
+  private handleDispatch;
+  private handleGatewayStatus;
+  private scheduleReconnect;
+  private setStatus;
+  static extractMeta(eventName: string, eventData: Record<string, unknown>): Record<string, string>;
+}
+//#endregion
+export { FlumeDiscordSource };

package/dist/discord.js

@@ -0,0 +1,2 @@
+import { t as FlumeDiscordSource } from "./discord-source-Q4JRIbNs.js";
+export { FlumeDiscordSource };