mixi2-js 1.2.1 → 1.3.0

package/dist/index.d.cts

@@ -1,46 +1,50 @@
-import { E as EventHandler, A as Authenticator } from './client-iXbbRxc-.cjs';
-export { a as AuthenticatorOptions, C as ChatMessage, b as ChatMessageReceivedEvent, c as Client, d as ClientOptions, e as CreatePostRequest, f as Event, g as EventReason, h as EventType, G as GetPostMediaStatusResponse, i as GetStampsRequest, I as InitiatePostMediaUploadRequest, j as InitiatePostMediaUploadResponse, L as LanguageCode, M as Media, k as MediaImage, l as MediaStamp, m as MediaType, n as MediaUploadStatus, o as MediaUploadType, p as MediaVideo, O as OAuth2Authenticator, q as OfficialStamp, r as OfficialStampSet, P as PingEvent, s as Post, t as PostAccessLevel, u as PostCreatedEvent, v as PostMask, w as PostMaskType, x as PostMedia, y as PostMediaImage, z as PostMediaType, B as PostMediaVideo, D as PostPublishingType, F as PostStamp, H as PostVisibility, S as SendChatMessageRequest, J as StampSetType, U as User, K as UserAccessLevel, N as UserAvatar, Q as UserVisibility } from './client-iXbbRxc-.cjs';
-import http from 'http';
+import { A as PostCreatedEvent, B as SendChatMessageRequest, C as MediaUploadType, D as PingEvent, E as OfficialStampSet, F as PostMediaType, G as UserVisibility, H as User, I as PostMediaVideo, L as PostPublishingType, M as PostMaskType, N as PostMedia, O as Post, P as PostMediaImage, R as PostStamp, S as MediaUploadStatus, T as OfficialStamp, U as UserAccessLevel, V as StampSetType, W as UserAvatar, _ as LanguageCode, a as OAuth2Authenticator, b as MediaStamp, c as ChatMessageReceivedEvent, d as EventReason, f as EventType, g as InitiatePostMediaUploadResponse, h as InitiatePostMediaUploadRequest, i as AuthenticatorOptions, j as PostMask, k as PostAccessLevel, l as CreatePostRequest, m as GetStampsRequest, n as ClientOptions, o as EventHandler, p as GetPostMediaStatusResponse, r as Authenticator, s as ChatMessage, t as Client, u as Event, v as Media, w as MediaVideo, x as MediaType, y as MediaImage, z as PostVisibility } from "./client-C90Zd_yq.cjs";
+import http from "http";
 
+//#region src/webhook.d.ts
 interface WebhookServerOptions {
-    port?: number;
-    publicKey: Buffer;
-    handler: EventHandler;
-    syncHandling?: boolean;
+  port?: number;
+  publicKey: Buffer;
+  handler: EventHandler;
+  syncHandling?: boolean;
 }
 declare class WebhookServer {
-    private readonly server;
-    private readonly port;
-    private readonly publicKey;
-    private readonly handler;
-    private readonly syncHandling;
-    constructor(options: WebhookServerOptions);
-    private requestListener;
-    private handleEvent;
-    start(): Promise<void>;
-    shutdown(): Promise<void>;
-    get address(): string;
-    get httpServer(): http.Server;
-    get eventHandlerFunc(): (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
+  private readonly server;
+  private readonly port;
+  private readonly publicKey;
+  private readonly handler;
+  private readonly syncHandling;
+  constructor(options: WebhookServerOptions);
+  private requestListener;
+  private handleEvent;
+  start(): Promise<void>;
+  shutdown(): Promise<void>;
+  get address(): string;
+  get httpServer(): http.Server;
+  get eventHandlerFunc(): (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
 }
-
+//#endregion
+//#region src/stream.d.ts
 interface StreamWatcherOptions {
-    streamAddress: string;
-    authenticator: Authenticator;
-    authKey?: string;
+  streamAddress: string;
+  authenticator: Authenticator;
+  authKey?: string;
+  /** 再接続の最大試行回数。デフォルト: 3 */
+  maxRetries?: number;
 }
 declare class StreamWatcher {
-    private readonly authenticator;
-    private readonly authKey?;
-    private readonly streamClient;
-    private aborted;
-    constructor(options: StreamWatcherOptions);
-    private getMetadata;
-    private connect;
-    private reconnect;
-    watch(handler: EventHandler): Promise<void>;
-    private handleEvent;
-    stop(): void;
+  private readonly authenticator;
+  private readonly authKey?;
+  private readonly streamClient;
+  private readonly maxRetries;
+  private aborted;
+  constructor(options: StreamWatcherOptions);
+  private getMetadata;
+  private connect;
+  private reconnect;
+  watch(handler: EventHandler): Promise<void>;
+  private handleEvent;
+  stop(): void;
 }
-
-export { Authenticator, EventHandler, StreamWatcher, type StreamWatcherOptions, WebhookServer, type WebhookServerOptions };
+//#endregion
+export { type Authenticator, type AuthenticatorOptions, type ChatMessage, type ChatMessageReceivedEvent, Client, type ClientOptions, type CreatePostRequest, type Event, type EventHandler, EventReason, EventType, type GetPostMediaStatusResponse, type GetStampsRequest, type InitiatePostMediaUploadRequest, type InitiatePostMediaUploadResponse, LanguageCode, type Media, type MediaImage, type MediaStamp, MediaType, MediaUploadStatus, MediaUploadType, type MediaVideo, OAuth2Authenticator, type OfficialStamp, type OfficialStampSet, type PingEvent, type Post, PostAccessLevel, type PostCreatedEvent, type PostMask, PostMaskType, type PostMedia, type PostMediaImage, PostMediaType, type PostMediaVideo, PostPublishingType, type PostStamp, PostVisibility, type SendChatMessageRequest, StampSetType, StreamWatcher, type StreamWatcherOptions, type User, UserAccessLevel, type UserAvatar, UserVisibility, WebhookServer, type WebhookServerOptions };

package/dist/index.d.mts

@@ -0,0 +1,50 @@
+import { A as PostCreatedEvent, B as SendChatMessageRequest, C as MediaUploadType, D as PingEvent, E as OfficialStampSet, F as PostMediaType, G as UserVisibility, H as User, I as PostMediaVideo, L as PostPublishingType, M as PostMaskType, N as PostMedia, O as Post, P as PostMediaImage, R as PostStamp, S as MediaUploadStatus, T as OfficialStamp, U as UserAccessLevel, V as StampSetType, W as UserAvatar, _ as LanguageCode, a as OAuth2Authenticator, b as MediaStamp, c as ChatMessageReceivedEvent, d as EventReason, f as EventType, g as InitiatePostMediaUploadResponse, h as InitiatePostMediaUploadRequest, i as AuthenticatorOptions, j as PostMask, k as PostAccessLevel, l as CreatePostRequest, m as GetStampsRequest, n as ClientOptions, o as EventHandler, p as GetPostMediaStatusResponse, r as Authenticator, s as ChatMessage, t as Client, u as Event, v as Media, w as MediaVideo, x as MediaType, y as MediaImage, z as PostVisibility } from "./client-DPeVTCYr.mjs";
+import http from "http";
+
+//#region src/webhook.d.ts
+interface WebhookServerOptions {
+  port?: number;
+  publicKey: Buffer;
+  handler: EventHandler;
+  syncHandling?: boolean;
+}
+declare class WebhookServer {
+  private readonly server;
+  private readonly port;
+  private readonly publicKey;
+  private readonly handler;
+  private readonly syncHandling;
+  constructor(options: WebhookServerOptions);
+  private requestListener;
+  private handleEvent;
+  start(): Promise<void>;
+  shutdown(): Promise<void>;
+  get address(): string;
+  get httpServer(): http.Server;
+  get eventHandlerFunc(): (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
+}
+//#endregion
+//#region src/stream.d.ts
+interface StreamWatcherOptions {
+  streamAddress: string;
+  authenticator: Authenticator;
+  authKey?: string;
+  /** 再接続の最大試行回数。デフォルト: 3 */
+  maxRetries?: number;
+}
+declare class StreamWatcher {
+  private readonly authenticator;
+  private readonly authKey?;
+  private readonly streamClient;
+  private readonly maxRetries;
+  private aborted;
+  constructor(options: StreamWatcherOptions);
+  private getMetadata;
+  private connect;
+  private reconnect;
+  watch(handler: EventHandler): Promise<void>;
+  private handleEvent;
+  stop(): void;
+}
+//#endregion
+export { type Authenticator, type AuthenticatorOptions, type ChatMessage, type ChatMessageReceivedEvent, Client, type ClientOptions, type CreatePostRequest, type Event, type EventHandler, EventReason, EventType, type GetPostMediaStatusResponse, type GetStampsRequest, type InitiatePostMediaUploadRequest, type InitiatePostMediaUploadResponse, LanguageCode, type Media, type MediaImage, type MediaStamp, MediaType, MediaUploadStatus, MediaUploadType, type MediaVideo, OAuth2Authenticator, type OfficialStamp, type OfficialStampSet, type PingEvent, type Post, PostAccessLevel, type PostCreatedEvent, type PostMask, PostMaskType, type PostMedia, type PostMediaImage, PostMediaType, type PostMediaVideo, PostPublishingType, type PostStamp, PostVisibility, type SendChatMessageRequest, StampSetType, StreamWatcher, type StreamWatcherOptions, type User, UserAccessLevel, type UserAvatar, UserVisibility, WebhookServer, type WebhookServerOptions };

package/dist/index.mjs

@@ -0,0 +1,559 @@
+import { a as MediaUploadStatus, c as PostMaskType, d as PostVisibility, f as StampSetType, i as MediaType, l as PostMediaType, m as UserVisibility, n as EventType, o as MediaUploadType, p as UserAccessLevel, r as LanguageCode, s as PostAccessLevel, t as EventReason, u as PostPublishingType } from "./types-BrJ83qtL.mjs";
+import * as grpc from "@grpc/grpc-js";
+import path from "path";
+import { fileURLToPath } from "url";
+import * as protoLoader from "@grpc/proto-loader";
+import http from "http";
+import crypto from "crypto";
+//#region src/auth.ts
+var OAuth2Authenticator = class {
+	clientId;
+	clientSecret;
+	tokenUrl;
+	accessToken = null;
+	expiresAt = null;
+	refreshPromise = null;
+	constructor(options) {
+		this.clientId = options.clientId;
+		this.clientSecret = options.clientSecret;
+		this.tokenUrl = options.tokenUrl;
+	}
+	async getAccessToken() {
+		if (this.accessToken && this.expiresAt && Date.now() < this.expiresAt) return this.accessToken;
+		if (!this.refreshPromise) this.refreshPromise = this.refreshToken().finally(() => {
+			this.refreshPromise = null;
+		});
+		await this.refreshPromise;
+		return this.accessToken;
+	}
+	async refreshToken() {
+		const credentials = Buffer.from(`${encodeURIComponent(this.clientId)}:${encodeURIComponent(this.clientSecret)}`).toString("base64");
+		const response = await fetch(this.tokenUrl, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/x-www-form-urlencoded",
+				Authorization: `Basic ${credentials}`
+			},
+			body: "grant_type=client_credentials"
+		});
+		if (!response.ok) throw new Error(`Failed to acquire access token: ${response.status} ${response.statusText}`);
+		const data = await response.json();
+		this.accessToken = data.access_token;
+		this.expiresAt = Date.now() + (data.expires_in - 60) * 1e3;
+	}
+};
+//#endregion
+//#region src/proto.ts
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PROTO_DIR = path.resolve(__dirname, "..", "proto");
+const PROTO_LOADER_OPTIONS = {
+	keepCase: false,
+	longs: Number,
+	enums: Number,
+	defaults: true,
+	oneofs: true
+};
+let _packageDefinition = null;
+let _grpcObject = null;
+function getPackageDefinition() {
+	if (!_packageDefinition) _packageDefinition = protoLoader.loadSync([
+		"social/mixi/application/service/application_api/v1/service.proto",
+		"social/mixi/application/service/application_stream/v1/service.proto",
+		"social/mixi/application/service/client_endpoint/v1/service.proto"
+	], {
+		...PROTO_LOADER_OPTIONS,
+		includeDirs: [PROTO_DIR]
+	});
+	return _packageDefinition;
+}
+function getGrpcObject() {
+	if (!_grpcObject) _grpcObject = grpc.loadPackageDefinition(getPackageDefinition());
+	return _grpcObject;
+}
+function resolveNested(obj, path) {
+	const parts = path.split(".");
+	let current = obj;
+	for (const part of parts) {
+		current = current[part];
+		if (current === void 0) throw new Error(`Could not resolve gRPC path: ${path}`);
+	}
+	return current;
+}
+function getApiServiceClient() {
+	return resolveNested(getGrpcObject(), "social.mixi.application.service.application_api.v1.ApplicationService");
+}
+function getStreamServiceClient() {
+	return resolveNested(getGrpcObject(), "social.mixi.application.service.application_stream.v1.ApplicationService");
+}
+function getSendEventRequestType() {
+	const msgDef = getPackageDefinition()["social.mixi.application.service.client_endpoint.v1.SendEventRequest"];
+	if (!msgDef || !("type" in msgDef)) throw new Error("SendEventRequest message type not found in proto");
+	return msgDef.type;
+}
+//#endregion
+//#region src/convert.ts
+function toDate(ts) {
+	if (!ts) return null;
+	if (ts instanceof Date) return ts;
+	const obj = ts;
+	if (obj.seconds !== void 0) {
+		const ms = Number(obj.seconds) * 1e3 + Math.floor((obj.nanos || 0) / 1e6);
+		return new Date(ms);
+	}
+	return null;
+}
+function convertUserAvatar(raw) {
+	if (!raw) return null;
+	const r = raw;
+	return {
+		largeImageUrl: r.largeImageUrl || "",
+		largeImageMimeType: r.largeImageMimeType || "",
+		largeImageHeight: r.largeImageHeight || 0,
+		largeImageWidth: r.largeImageWidth || 0,
+		smallImageUrl: r.smallImageUrl || "",
+		smallImageMimeType: r.smallImageMimeType || "",
+		smallImageHeight: r.smallImageHeight || 0,
+		smallImageWidth: r.smallImageWidth || 0
+	};
+}
+function convertUser(raw) {
+	const r = raw;
+	return {
+		userId: r.userId || "",
+		isDisabled: r.isDisabled || false,
+		name: r.name || "",
+		displayName: r.displayName || "",
+		profile: r.profile || "",
+		userAvatar: convertUserAvatar(r.userAvatar),
+		visibility: r.visibility || 0,
+		accessLevel: r.accessLevel || 0
+	};
+}
+function convertMediaImage(raw) {
+	if (!raw) return void 0;
+	const r = raw;
+	return {
+		largeImageUrl: r.largeImageUrl || "",
+		largeImageMimeType: r.largeImageMimeType || "",
+		largeImageHeight: r.largeImageHeight || 0,
+		largeImageWidth: r.largeImageWidth || 0,
+		smallImageUrl: r.smallImageUrl || "",
+		smallImageMimeType: r.smallImageMimeType || "",
+		smallImageHeight: r.smallImageHeight || 0,
+		smallImageWidth: r.smallImageWidth || 0
+	};
+}
+function convertMediaVideo(raw) {
+	if (!raw) return void 0;
+	const r = raw;
+	return {
+		videoUrl: r.videoUrl || "",
+		videoMimeType: r.videoMimeType || "",
+		videoHeight: r.videoHeight || 0,
+		videoWidth: r.videoWidth || 0,
+		previewImageUrl: r.previewImageUrl || "",
+		previewImageMimeType: r.previewImageMimeType || "",
+		previewImageHeight: r.previewImageHeight || 0,
+		previewImageWidth: r.previewImageWidth || 0,
+		duration: r.duration || 0
+	};
+}
+function convertMedia(raw) {
+	const r = raw;
+	return {
+		mediaType: r.mediaType || 0,
+		image: convertMediaImage(r.image),
+		video: convertMediaVideo(r.video)
+	};
+}
+function convertMediaStamp(raw) {
+	if (!raw) return null;
+	const r = raw;
+	return {
+		url: r.url || "",
+		mimeType: r.mimeType || "",
+		height: r.height || 0,
+		width: r.width || 0
+	};
+}
+function convertPostMedia(raw) {
+	const r = raw;
+	return {
+		mediaType: r.mediaType || 0,
+		image: r.image ? convertMediaImage(r.image) : void 0,
+		video: r.video ? convertMediaVideo(r.video) : void 0
+	};
+}
+function convertPostMask(raw) {
+	if (!raw) return void 0;
+	const r = raw;
+	return {
+		maskType: r.maskType || 0,
+		caption: r.caption || ""
+	};
+}
+function convertPostStamp(raw) {
+	const r = raw;
+	return {
+		stamp: convertMediaStamp(r.stamp),
+		count: Number(r.count) || 0
+	};
+}
+function convertPost(raw) {
+	const r = raw;
+	return {
+		postId: r.postId || "",
+		isDeleted: r.isDeleted || false,
+		creatorId: r.creatorId || "",
+		text: r.text || "",
+		createdAt: toDate(r.createdAt),
+		postMediaList: (r.postMediaList || []).map(convertPostMedia),
+		inReplyToPostId: r.inReplyToPostId || void 0,
+		postMask: convertPostMask(r.postMask),
+		visibility: r.visibility || 0,
+		accessLevel: r.accessLevel || 0,
+		stamps: (r.stamps || []).map(convertPostStamp),
+		readerStampId: r.readerStampId || void 0
+	};
+}
+function convertChatMessage(raw) {
+	const r = raw;
+	return {
+		roomId: r.roomId || "",
+		messageId: r.messageId || "",
+		creatorId: r.creatorId || "",
+		text: r.text || "",
+		createdAt: toDate(r.createdAt),
+		mediaList: (r.mediaList || []).map(convertMedia),
+		postId: r.postId || void 0
+	};
+}
+function convertOfficialStamp(raw) {
+	const r = raw;
+	return {
+		stampId: r.stampId || "",
+		index: r.index || 0,
+		searchTags: r.searchTags || [],
+		url: r.url || ""
+	};
+}
+function convertOfficialStampSet(raw) {
+	const r = raw;
+	return {
+		name: r.name || "",
+		spriteUrl: r.spriteUrl || "",
+		stamps: (r.stamps || []).map(convertOfficialStamp),
+		stampSetId: r.stampSetId || "",
+		startAt: toDate(r.startAt) ?? void 0,
+		endAt: toDate(r.endAt) ?? void 0,
+		stampSetType: r.stampSetType || 0
+	};
+}
+function convertPostCreatedEvent(raw) {
+	const r = raw;
+	return {
+		eventReasonList: r.eventReasonList || [],
+		post: r.post ? convertPost(r.post) : null,
+		issuer: r.issuer ? convertUser(r.issuer) : null
+	};
+}
+function convertChatMessageReceivedEvent(raw) {
+	const r = raw;
+	return {
+		eventReasonList: r.eventReasonList || [],
+		message: r.message ? convertChatMessage(r.message) : null,
+		issuer: r.issuer ? convertUser(r.issuer) : null
+	};
+}
+function convertEvent(raw) {
+	const r = raw;
+	return {
+		eventId: r.eventId || "",
+		eventType: r.eventType || 0,
+		pingEvent: r.pingEvent || void 0,
+		postCreatedEvent: r.postCreatedEvent ? convertPostCreatedEvent(r.postCreatedEvent) : void 0,
+		chatMessageReceivedEvent: r.chatMessageReceivedEvent ? convertChatMessageReceivedEvent(r.chatMessageReceivedEvent) : void 0
+	};
+}
+//#endregion
+//#region src/client.ts
+var Client = class {
+	grpcClient;
+	authenticator;
+	authKey;
+	constructor(options) {
+		this.grpcClient = new (getApiServiceClient())(options.apiAddress, grpc.credentials.createSsl());
+		this.authenticator = options.authenticator;
+		this.authKey = options.authKey;
+	}
+	async getMetadata() {
+		const token = await this.authenticator.getAccessToken();
+		const metadata = new grpc.Metadata();
+		metadata.add("authorization", `Bearer ${token}`);
+		if (this.authKey) metadata.add("x-auth-key", this.authKey);
+		return metadata;
+	}
+	call(method, request) {
+		return this.getMetadata().then((metadata) => {
+			return new Promise((resolve, reject) => {
+				const fn = this.grpcClient[method];
+				if (!fn) {
+					reject(/* @__PURE__ */ new Error(`Method "${method}" not found on gRPC client`));
+					return;
+				}
+				fn.call(this.grpcClient, request, metadata, (err, response) => {
+					if (err) reject(err);
+					else resolve(response);
+				});
+			});
+		});
+	}
+	async getUsers(userIdList) {
+		return ((await this.call("getUsers", { userIdList })).users || []).map(convertUser);
+	}
+	async getPosts(postIdList) {
+		return ((await this.call("getPosts", { postIdList })).posts || []).map(convertPost);
+	}
+	async createPost(request) {
+		return convertPost((await this.call("createPost", request)).post);
+	}
+	async initiatePostMediaUpload(request) {
+		return this.call("initiatePostMediaUpload", request);
+	}
+	async getPostMediaStatus(mediaId) {
+		return this.call("getPostMediaStatus", { mediaId });
+	}
+	async sendChatMessage(request) {
+		return convertChatMessage((await this.call("sendChatMessage", request)).message);
+	}
+	async getStamps(request) {
+		return ((await this.call("getStamps", request || {})).officialStampSets || []).map(convertOfficialStampSet);
+	}
+	async addStampToPost(postId, stampId) {
+		return convertPost((await this.call("addStampToPost", {
+			postId,
+			stampId
+		})).post);
+	}
+	close() {
+		this.grpcClient.close();
+	}
+};
+//#endregion
+//#region src/webhook.ts
+const TIMESTAMP_TOLERANCE = 300;
+var WebhookServer = class {
+	server;
+	port;
+	publicKey;
+	handler;
+	syncHandling;
+	constructor(options) {
+		this.port = options.port || 8080;
+		this.handler = options.handler;
+		this.syncHandling = options.syncHandling || false;
+		const derPrefix = Buffer.from("302a300506032b6570032100", "hex");
+		const derKey = Buffer.concat([derPrefix, options.publicKey]);
+		this.publicKey = crypto.createPublicKey({
+			key: derKey,
+			format: "der",
+			type: "spki"
+		});
+		this.server = http.createServer(this.requestListener.bind(this));
+	}
+	async requestListener(req, res) {
+		if (req.method === "GET" && req.url === "/healthz") {
+			res.writeHead(200);
+			res.end("OK");
+			return;
+		}
+		if (req.method === "POST" && req.url === "/events") {
+			await this.handleEvent(req, res);
+			return;
+		}
+		res.writeHead(404);
+		res.end("Not Found");
+	}
+	async handleEvent(req, res) {
+		const signatureBase64 = req.headers["x-mixi2-application-event-signature"];
+		if (!signatureBase64) {
+			res.writeHead(401);
+			res.end("missing x-mixi2-application-event-signature");
+			return;
+		}
+		const signature = Buffer.from(signatureBase64, "base64");
+		if (signature.length === 0) {
+			res.writeHead(401);
+			res.end("x-mixi2-application-event-signature is invalid");
+			return;
+		}
+		const timestamp = req.headers["x-mixi2-application-event-timestamp"];
+		if (!timestamp) {
+			res.writeHead(401);
+			res.end("missing x-mixi2-application-event-timestamp");
+			return;
+		}
+		const unixTime = parseInt(timestamp, 10);
+		if (isNaN(unixTime)) {
+			res.writeHead(401);
+			res.end("x-mixi2-application-event-timestamp is invalid");
+			return;
+		}
+		const diff = Math.floor(Date.now() / 1e3) - unixTime;
+		if (diff > TIMESTAMP_TOLERANCE) {
+			res.writeHead(401);
+			res.end("x-mixi2-application-event-timestamp is too old");
+			return;
+		}
+		if (diff < -TIMESTAMP_TOLERANCE) {
+			res.writeHead(401);
+			res.end("x-mixi2-application-event-timestamp is in the future");
+			return;
+		}
+		const body = await new Promise((resolve, reject) => {
+			const chunks = [];
+			req.on("data", (chunk) => chunks.push(chunk));
+			req.on("end", () => resolve(Buffer.concat(chunks)));
+			req.on("error", reject);
+		});
+		const dataToVerify = Buffer.concat([body, Buffer.from(timestamp)]);
+		if (!crypto.verify(null, dataToVerify, this.publicKey, signature)) {
+			res.writeHead(401);
+			res.end("Signature is invalid");
+			return;
+		}
+		let events;
+		try {
+			events = (getSendEventRequestType().decode(new Uint8Array(body)).events || []).map(convertEvent);
+		} catch {
+			res.writeHead(400);
+			res.end("Failed to parse request body");
+			return;
+		}
+		res.writeHead(204);
+		res.end();
+		for (const event of events) {
+			if (event.eventType === EventType.PING) continue;
+			if (this.syncHandling) try {
+				await this.handler.handle(event);
+			} catch (err) {
+				console.error(`Failed to handle event ${event.eventId}:`, err);
+			}
+			else Promise.resolve(this.handler.handle(event)).catch((err) => {
+				console.error(`Failed to handle event ${event.eventId}:`, err);
+			});
+		}
+	}
+	start() {
+		return new Promise((resolve) => {
+			this.server.listen(this.port, () => {
+				resolve();
+			});
+		});
+	}
+	shutdown() {
+		return new Promise((resolve, reject) => {
+			this.server.close((err) => {
+				if (err) reject(err);
+				else resolve();
+			});
+		});
+	}
+	get address() {
+		return `:${this.port}`;
+	}
+	get httpServer() {
+		return this.server;
+	}
+	get eventHandlerFunc() {
+		return this.handleEvent.bind(this);
+	}
+};
+//#endregion
+//#region src/stream.ts
+var StreamWatcher = class {
+	authenticator;
+	authKey;
+	streamClient;
+	maxRetries;
+	aborted = false;
+	constructor(options) {
+		this.streamClient = new (getStreamServiceClient())(options.streamAddress, grpc.credentials.createSsl());
+		this.authenticator = options.authenticator;
+		this.authKey = options.authKey;
+		this.maxRetries = options.maxRetries ?? 3;
+	}
+	async getMetadata() {
+		const token = await this.authenticator.getAccessToken();
+		const metadata = new grpc.Metadata();
+		metadata.add("authorization", `Bearer ${token}`);
+		if (this.authKey) metadata.add("x-auth-key", this.authKey);
+		return metadata;
+	}
+	async connect() {
+		const metadata = await this.getMetadata();
+		const fn = this.streamClient["subscribeEvents"];
+		if (!fn) throw new Error("subscribeEvents method not found on stream client");
+		return fn.call(this.streamClient, {}, metadata);
+	}
+	async reconnect() {
+		const maxRetries = this.maxRetries;
+		let lastError;
+		for (let i = 0; i < maxRetries; i++) {
+			if (this.aborted) throw new Error("Watcher aborted");
+			await new Promise((resolve) => setTimeout(resolve, Math.pow(2, i) * 1e3));
+			try {
+				return await this.connect();
+			} catch (err) {
+				lastError = err instanceof Error ? err : new Error(String(err));
+				console.warn(`Reconnect attempt ${i + 1}/${maxRetries} failed:`, lastError.message);
+			}
+		}
+		throw lastError || /* @__PURE__ */ new Error("Failed to reconnect");
+	}
+	async watch(handler) {
+		this.aborted = false;
+		let stream = await this.connect();
+		return new Promise((resolve, reject) => {
+			const setupStream = (s) => {
+				s.on("data", (response) => {
+					const events = (response.events || []).map(convertEvent);
+					for (const event of events) {
+						if (event.eventType === EventType.PING) continue;
+						this.handleEvent(handler, event);
+					}
+				});
+				let disconnected = false;
+				const handleDisconnect = async () => {
+					if (disconnected) return;
+					disconnected = true;
+					if (this.aborted) {
+						resolve();
+						return;
+					}
+					try {
+						stream = await this.reconnect();
+						setupStream(stream);
+					} catch (reconnectErr) {
+						reject(reconnectErr);
+					}
+				};
+				s.on("error", handleDisconnect);
+				s.on("end", handleDisconnect);
+			};
+			setupStream(stream);
+		});
+	}
+	handleEvent(handler, event) {
+		Promise.resolve(handler.handle(event)).catch((err) => {
+			console.error(`Failed to handle event ${event.eventId}:`, err);
+		});
+	}
+	stop() {
+		this.aborted = true;
+		this.streamClient.close();
+	}
+};
+//#endregion
+export { Client, EventReason, EventType, LanguageCode, MediaType, MediaUploadStatus, MediaUploadType, OAuth2Authenticator, PostAccessLevel, PostMaskType, PostMediaType, PostPublishingType, PostVisibility, StampSetType, StreamWatcher, UserAccessLevel, UserVisibility, WebhookServer };