@interactive-inc/flume 0.1.0 → 0.2.0

package/dist/slack.js

@@ -1,2 +1,443 @@
-import { t as FlumeSlackSource } from "./slack-source-CszepStG.js";
-export { FlumeSlackSource };
+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 FlumeHttpError } from "./http-error-BtXonO-W.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 { t as safeFetch } from "./safe-fetch-30ZzOKHL.js";
+import { z } from "zod/v4";
+//#region lib/slack/extract-slack-meta.ts
+function extractSlackMeta(envelope) {
+	const meta = { event_type: envelope.type };
+	const eventPayload = isRecord(envelope.payload.event) ? envelope.payload.event : null;
+	if (!eventPayload) return meta;
+	if (typeof eventPayload.channel === "string") meta.channel_id = eventPayload.channel;
+	if (typeof eventPayload.user === "string") meta.user_id = eventPayload.user;
+	if (typeof eventPayload.thread_ts === "string") meta.thread_ts = eventPayload.thread_ts;
+	if (typeof eventPayload.type === "string") meta.slack_event_type = eventPayload.type;
+	return meta;
+}
+//#endregion
+//#region lib/slack/slack-seen-cache.ts
+/**
+* Slack envelope_id の LRU 風キャッシュ。Slack は ack 失敗時に同じ envelope を再送するため、
+* source レイヤで handler への重複配送を防ぐ
+*/
+var FlumeSlackSeenCache = class {
+	props;
+	seen = /* @__PURE__ */ new Set();
+	constructor(props) {
+		this.props = props;
+	}
+	has(envelopeId) {
+		return this.seen.has(envelopeId);
+	}
+	add(envelopeId) {
+		this.seen.add(envelopeId);
+	}
+	trim() {
+		if (this.seen.size <= this.props.maxSize) return;
+		const entries = [...this.seen];
+		this.seen = new Set(entries.slice(entries.length - this.props.maxSize));
+	}
+	get size() {
+		return this.seen.size;
+	}
+};
+//#endregion
+//#region lib/slack/slack-envelope-schema.ts
+const FlumeSlackEnvelopeSchema = z.object({
+	envelope_id: z.string(),
+	type: z.string(),
+	payload: z.record(z.string(), z.unknown()),
+	accepts_response_payload: z.boolean().optional(),
+	retry_attempt: z.number().optional(),
+	retry_reason: z.string().optional()
+});
+//#endregion
+//#region lib/slack/slack-connection-response-schema.ts
+const FlumeSlackConnectionResponseSchema = z.object({
+	ok: z.boolean(),
+	url: z.string().optional(),
+	error: z.string().optional()
+});
+//#endregion
+//#region lib/slack/obtain-slack-url.ts
+async function obtainSlackUrl(props) {
+	const log = new FlumeLogger({
+		source: "slack.url",
+		handler: props.onLog,
+		deps: props.deps
+	});
+	const url = "https://slack.com/api/apps.connections.open";
+	log.debug({
+		action: "http.request",
+		message: `POST ${url}`
+	});
+	const response = await safeFetch({
+		fetch: props.deps.fetch,
+		url,
+		init: {
+			method: "POST",
+			headers: { Authorization: `Bearer ${props.appToken}` }
+		},
+		log
+	});
+	if (response instanceof Error) return new FlumeHttpError({
+		message: response.message,
+		status: 0
+	});
+	log.debug({
+		action: "http.response",
+		message: `POST ${response.status}`,
+		detail: {
+			status: response.status,
+			url
+		}
+	});
+	const raw = await response.json();
+	const peek = isRecord(raw) ? raw : {};
+	log.debug({
+		action: "http.body",
+		message: "apps.connections.open response",
+		detail: {
+			ok: peek.ok,
+			error: peek.error
+		}
+	});
+	const parsed = FlumeSlackConnectionResponseSchema.safeParse(raw);
+	if (!parsed.success) {
+		log.warn({
+			action: "parse.fail",
+			message: "apps.connections.open: invalid response shape",
+			detail: { issues: parsed.error.issues.map((i) => ({
+				path: i.path,
+				message: i.message
+			})) }
+		});
+		return new FlumeHttpError({
+			message: "apps.connections.open: invalid response shape",
+			status: response.status
+		});
+	}
+	if (!parsed.data.ok || !parsed.data.url) {
+		log.warn({
+			action: "api.fail",
+			message: `apps.connections.open failed: ${parsed.data.error ?? "no url"}`
+		});
+		return new FlumeHttpError({
+			message: `apps.connections.open failed: ${parsed.data.error ?? "no url"}`,
+			status: response.status
+		});
+	}
+	log.info({
+		action: "url.obtained",
+		message: "WSS URL obtained"
+	});
+	return parsed.data.url;
+}
+//#endregion
+//#region lib/slack/slack-socket-mode.ts
+function framePreview(raw) {
+	return raw.length > 200 ? `${raw.slice(0, 200)}... (${raw.length} bytes)` : raw;
+}
+var FlumeSlackSocketMode = class {
+	props;
+	log;
+	ws = null;
+	stopped = false;
+	pendingResolve = null;
+	pendingResolved = false;
+	constructor(props) {
+		this.props = props;
+		this.log = new FlumeLogger({
+			source: "slack.socket-mode",
+			handler: props.onLog,
+			deps: props.deps
+		});
+	}
+	async connect() {
+		this.log.info({
+			action: "connect.start",
+			message: "opening WebSocket connection"
+		});
+		const url = await obtainSlackUrl({
+			appToken: this.props.appToken,
+			onLog: this.props.onLog,
+			deps: this.props.deps
+		});
+		if (url instanceof FlumeHttpError) {
+			this.log.error({
+				action: "http.error",
+				message: url.message,
+				error: url
+			});
+			return url;
+		}
+		this.log.info({
+			action: "url.obtained",
+			message: "WebSocket URL obtained"
+		});
+		return this.openSocket(url);
+	}
+	disconnect() {
+		this.log.info({
+			action: "disconnect",
+			message: "stopping socket mode"
+		});
+		this.stopped = true;
+		if (this.ws) {
+			this.ws.close();
+			this.ws = null;
+		}
+	}
+	isConnected() {
+		return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+	}
+	openSocket(url) {
+		this.pendingResolved = false;
+		return new Promise((resolve) => {
+			this.pendingResolve = resolve;
+			const socket = new this.props.deps.WebSocket(url);
+			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());
+		});
+	}
+	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 json = safeJsonParse(raw);
+		if (!isRecord(json)) {
+			this.log.error({
+				action: "ws.parse-error",
+				message: "invalid JSON",
+				error: new FlumeParseError(raw.slice(0, 200))
+			});
+			return;
+		}
+		if (json.type === "hello") {
+			this.log.info({
+				action: "ws.hello",
+				message: "connection ready"
+			});
+			this.props.onConnected();
+			this.completeConnect(null);
+			return;
+		}
+		if (json.type === "disconnect") {
+			const reason = typeof json.reason === "string" ? json.reason : "unknown";
+			this.log.info({
+				action: "ws.disconnect-requested",
+				message: `reason=${reason}`,
+				detail: { reason }
+			});
+			socket.close();
+			return;
+		}
+		if (typeof json.envelope_id === "string") {
+			this.log.debug({
+				action: "ws.ack",
+				message: `envelope_id=${json.envelope_id}`
+			});
+			const ack = JSON.stringify({ envelope_id: json.envelope_id });
+			socket.send(ack);
+			this.log.debug({
+				action: "ws.send",
+				message: framePreview(ack)
+			});
+		}
+		const envelope = FlumeSlackEnvelopeSchema.safeParse(json);
+		if (envelope.success) {
+			this.log.debug({
+				action: "envelope.recv",
+				message: `type=${envelope.data.type} envelope_id=${envelope.data.envelope_id}`,
+				detail: {
+					type: envelope.data.type,
+					envelopeId: envelope.data.envelope_id
+				}
+			});
+			this.props.onMessage(envelope.data);
+			return;
+		}
+		this.log.warn({
+			action: "envelope.parse-fail",
+			message: "unrecognised envelope shape, dropping",
+			detail: {
+				type: typeof json.type === "string" ? json.type : "unknown",
+				issues: envelope.error.issues.map((i) => ({
+					path: i.path,
+					message: i.message
+				}))
+			}
+		});
+	}
+	onClose(ev) {
+		this.log.info({
+			action: "ws.close",
+			message: `code=${ev.code} reason=${ev.reason || "none"}`
+		});
+		this.ws = null;
+		this.props.onDisconnected();
+		this.completeConnect(new FlumeConnectionError(`WebSocket closed before hello (code=${ev.code})`));
+	}
+	onError() {
+		this.log.error({
+			action: "ws.error",
+			message: "WebSocket error event"
+		});
+		this.completeConnect(new FlumeConnectionError("WebSocket connection error"));
+	}
+};
+//#endregion
+//#region lib/slack/slack-source.ts
+const SEEN_CACHE_MAX = 1024;
+var FlumeSlackSource = class {
+	options;
+	name = "slack";
+	socket = null;
+	reconnector = null;
+	handler = null;
+	currentStatus = "disconnected";
+	log;
+	deps;
+	queue = new FlumeSerialQueue();
+	seen = new FlumeSlackSeenCache({ maxSize: SEEN_CACHE_MAX });
+	constructor(options) {
+		this.options = options;
+		this.deps = options.deps ?? createFlumeDefaultDeps();
+		this.log = new FlumeLogger({
+			source: "slack",
+			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("Slack source: signal already aborted");
+		this.options.signal?.addEventListener("abort", () => this.stop(), { once: true });
+		this.handler = handler;
+		this.log.info({
+			action: "start",
+			message: "starting Slack source"
+		});
+		return this.connectInternal();
+	}
+	async stop() {
+		this.log.info({
+			action: "stop",
+			message: "stopping Slack source"
+		});
+		if (this.reconnector && !this.reconnector.aborted) this.log.debug({
+			action: "reconnect.cancel",
+			message: "aborting reconnector"
+		});
+		this.reconnector?.cancel();
+		this.socket?.disconnect();
+		this.socket = null;
+		this.handler = null;
+		await this.queue.drain();
+		this.setStatus("disconnected");
+	}
+	status() {
+		return this.currentStatus;
+	}
+	async connectInternal() {
+		this.setStatus("connecting");
+		this.socket = new FlumeSlackSocketMode({
+			appToken: this.options.appToken,
+			onLog: this.options.onLog,
+			deps: this.deps,
+			onMessage: (envelope) => this.handleMessage(envelope),
+			onConnected: () => {
+				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");
+			},
+			onDisconnected: () => {
+				if (!this.socket?.stopped) this.scheduleReconnect();
+			}
+		});
+		const error = await this.socket.connect();
+		if (error instanceof Error) {
+			this.log.error({
+				action: "connect.failed",
+				message: error.message,
+				error
+			});
+			if (!this.reconnector || this.reconnector.aborted) {
+				this.setStatus("disconnected");
+				return error;
+			}
+			this.scheduleReconnect();
+		}
+	}
+	handleMessage(envelope) {
+		if (this.seen.has(envelope.envelope_id)) {
+			this.log.debug({
+				action: "dedup.skip",
+				message: `duplicate envelope_id=${envelope.envelope_id}`,
+				detail: {
+					envelope_id: envelope.envelope_id,
+					retry_attempt: envelope.retry_attempt
+				}
+			});
+			return;
+		}
+		this.seen.add(envelope.envelope_id);
+		this.seen.trim();
+		const event = {
+			source: "slack",
+			type: envelope.type,
+			data: envelope.payload,
+			meta: extractSlackMeta(envelope),
+			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))
+				});
+			}
+		});
+	}
+	scheduleReconnect() {
+		scheduleFlumeReconnect({
+			reconnector: this.reconnector,
+			log: this.log,
+			setStatus: (status) => this.setStatus(status),
+			retry: () => {
+				this.connectInternal();
+			}
+		});
+	}
+	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 { FlumeSlackConnectionResponseSchema, FlumeSlackEnvelopeSchema, FlumeSlackSeenCache, FlumeSlackSocketMode, FlumeSlackSource, extractSlackMeta, obtainSlackUrl };

package/dist/{types-BVQSU336.d.ts → types-tnOPBc1p.d.ts}

@@ -1,25 +1,14 @@
 import { z } from "zod/v4";
 
-//#region lib/schema.d.ts
+//#region lib/discord/discord-gateway-message-schema.d.ts
 declare const FlumeGatewayMessageSchema: z.ZodObject<{
   op: z.ZodNumber;
   d: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   s: z.ZodNullable<z.ZodNumber>;
   t: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
-declare const FlumeSlackEnvelopeSchema: z.ZodObject<{
-  envelope_id: z.ZodString;
-  type: z.ZodString;
-  payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-  accepts_response_payload: z.ZodOptional<z.ZodBoolean>;
-  retry_attempt: z.ZodOptional<z.ZodNumber>;
-  retry_reason: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const FlumeSlackConnectionResponseSchema: z.ZodObject<{
-  ok: z.ZodBoolean;
-  url: z.ZodOptional<z.ZodString>;
-  error: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+//#endregion
+//#region lib/github/github-notification-schema.d.ts
 declare const FlumeGitHubNotificationSchema: z.ZodObject<{
   id: z.ZodString;
   reason: z.ZodString;
@@ -35,6 +24,23 @@ declare const FlumeGitHubNotificationSchema: z.ZodObject<{
   }, z.core.$strip>;
 }, z.core.$strip>;
 //#endregion
+//#region lib/slack/slack-connection-response-schema.d.ts
+declare const FlumeSlackConnectionResponseSchema: z.ZodObject<{
+  ok: z.ZodBoolean;
+  url: z.ZodOptional<z.ZodString>;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//#endregion
+//#region lib/slack/slack-envelope-schema.d.ts
+declare const FlumeSlackEnvelopeSchema: z.ZodObject<{
+  envelope_id: z.ZodString;
+  type: z.ZodString;
+  payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  accepts_response_payload: z.ZodOptional<z.ZodBoolean>;
+  retry_attempt: z.ZodOptional<z.ZodNumber>;
+  retry_reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//#endregion
 //#region lib/types.d.ts
 type FlumeTimerHandle = ReturnType<typeof setTimeout>;
 type FlumeRuntimeDeps = {
@@ -56,6 +62,16 @@ type FlumeEvent = {
   receivedAt: number;
 };
 type FlumeHandler = (event: FlumeEvent) => void | Promise<void>;
+type FlumeSource = {
+  readonly name: FlumeSourceName;
+  start(handler: FlumeHandler): Promise<void | Error>;
+  stop(): Promise<void>;
+  status(): FlumeStatus;
+};
+type FlumeSourceStatus = {
+  name: FlumeSourceName;
+  status: FlumeStatus;
+};
 type FlumeStatus = "disconnected" | "connecting" | "connected" | "reconnecting";
 type FlumeStatusHandler = (status: FlumeStatus, detail?: string) => void;
 type FlumeLogLevel = "debug" | "info" | "warn" | "error";
@@ -90,7 +106,7 @@ type FlumeSourceOptions = {
   onStatus?: FlumeStatusHandler;
   onLog?: FlumeLogHandler;
   signal?: AbortSignal;
-  deps: FlumeRuntimeDeps;
+  deps?: FlumeRuntimeDeps;
 };
 type FlumeDiscordSourceOptions = FlumeSourceOptions & {
   token: string;
@@ -109,4 +125,4 @@ type FlumeSlackEnvelope = z.infer<typeof FlumeSlackEnvelopeSchema>;
 type FlumeSlackConnectionResponse = z.infer<typeof FlumeSlackConnectionResponseSchema>;
 type FlumeGitHubNotification = z.infer<typeof FlumeGitHubNotificationSchema>;
 //#endregion
-export { FlumeGitHubNotificationSchema as C, FlumeGatewayMessageSchema as S, FlumeSlackEnvelopeSchema as T, FlumeSourceName as _, FlumeGitHubSourceOptions as a, FlumeStatusHandler as b, FlumeLogHandler as c, FlumeReconnectConfig as d, FlumeReconnectOptions as f, FlumeSlackSourceOptions as g, FlumeSlackEnvelope as h, FlumeGitHubNotification as i, FlumeLogInput as l, FlumeSlackConnectionResponse as m, FlumeEvent as n, FlumeHandler as o, FlumeRuntimeDeps as p, FlumeGatewayMessage as r, FlumeLog as s, FlumeDiscordSourceOptions as t, FlumeLogLevel as u, FlumeSourceOptions as v, FlumeSlackConnectionResponseSchema as w, FlumeTimerHandle as x, FlumeStatus as y };
+export { FlumeTimerHandle as C, FlumeGatewayMessageSchema as D, FlumeGitHubNotificationSchema as E, FlumeStatusHandler as S, FlumeSlackConnectionResponseSchema as T, FlumeSource as _, FlumeGitHubSourceOptions as a, FlumeSourceStatus as b, FlumeLogHandler as c, FlumeReconnectConfig as d, FlumeReconnectOptions as f, FlumeSlackSourceOptions as g, FlumeSlackEnvelope as h, FlumeGitHubNotification as i, FlumeLogInput as l, FlumeSlackConnectionResponse as m, FlumeEvent as n, FlumeHandler as o, FlumeRuntimeDeps as p, FlumeGatewayMessage as r, FlumeLog as s, FlumeDiscordSourceOptions as t, FlumeLogLevel as u, FlumeSourceName as v, FlumeSlackEnvelopeSchema as w, FlumeStatus as x, FlumeSourceOptions as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interactive-inc/flume",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Unified notification listener for Discord, Slack, and GitHub. Raw WebSocket + fetch + Zod. No SDK dependencies.",
   "keywords": [
     "discord",