@aigne/afs-discord 1.11.0-beta.12

package/LICENSE.md

@@ -0,0 +1,26 @@
+# Proprietary License
+
+Copyright (c) 2024-2025 ArcBlock, Inc. All Rights Reserved.
+
+This software and associated documentation files (the "Software") are proprietary
+and confidential. Unauthorized copying, modification, distribution, or use of
+this Software, via any medium, is strictly prohibited.
+
+The Software is provided for internal use only within ArcBlock, Inc. and its
+authorized affiliates.
+
+## No License Granted
+
+No license, express or implied, is granted to any party for any purpose.
+All rights are reserved by ArcBlock, Inc.
+
+## Public Artifact Distribution
+
+Portions of this Software may be released publicly under separate open-source
+licenses (such as MIT License) through designated public repositories. Such
+public releases are governed by their respective licenses and do not affect
+the proprietary nature of this repository.
+
+## Contact
+
+For licensing inquiries, contact: legal@arcblock.io

package/dist/index.cjs

@@ -0,0 +1,601 @@
+let _aigne_afs_provider = require("@aigne/afs/provider");
+let _aigne_afs_messaging = require("@aigne/afs-messaging");
+
+//#region src/client.ts
+/**
+* DiscordClient — pure Discord REST API wrapper.
+*
+* Zero external dependencies (uses native fetch).
+* No AFS or application-specific concepts.
+* Gateway WebSocket is handled by the provider, not the client.
+*/
+const DEFAULT_API_BASE = "https://discord.com/api/v10";
+const DEFAULT_TIMEOUT = 3e4;
+var DiscordClient = class {
+	_token;
+	_apiBase;
+	_timeout;
+	constructor(options) {
+		if (!options.token) throw new Error("DiscordClient requires a token");
+		this._token = options.token;
+		this._apiBase = options.apiBase ?? DEFAULT_API_BASE;
+		this._timeout = options.timeout ?? DEFAULT_TIMEOUT;
+	}
+	async sendMessage(channelId, text, options) {
+		const body = { content: text };
+		if (options?.replyTo) body.message_reference = { message_id: options.replyTo };
+		if (options?.embeds) body.embeds = options.embeds;
+		return this._call("POST", `/channels/${channelId}/messages`, body);
+	}
+	async triggerTyping(channelId) {
+		await this._call("POST", `/channels/${channelId}/typing`);
+	}
+	async getGatewayUrl() {
+		return (await this._call("GET", "/gateway/bot")).url;
+	}
+	async getCurrentUser() {
+		return this._call("GET", "/users/@me");
+	}
+	static escapeMarkdown(text) {
+		return text.replace(/([*_~`|\\])/g, "\\$1");
+	}
+	async _call(method, path, body) {
+		const headers = { Authorization: `Bot ${this._token}` };
+		const init = {
+			method,
+			headers,
+			signal: AbortSignal.timeout(this._timeout)
+		};
+		if (body) {
+			headers["Content-Type"] = "application/json";
+			init.body = JSON.stringify(body);
+		}
+		const response = await fetch(`${this._apiBase}${path}`, init);
+		if (!response.ok) {
+			const desc = (await response.text().catch(() => "")).replace(this._token, "***");
+			throw new Error(`Discord API error ${response.status}: ${desc}`);
+		}
+		if (response.status === 204) return void 0;
+		return response.json();
+	}
+};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.108.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+//#region src/index.ts
+const GatewayOp = {
+	DISPATCH: 0,
+	HEARTBEAT: 1,
+	IDENTIFY: 2,
+	RESUME: 6,
+	RECONNECT: 7,
+	INVALID_SESSION: 9,
+	HELLO: 10,
+	HEARTBEAT_ACK: 11
+};
+const DEFAULT_INTENTS = 37377;
+var AFSDiscord = class extends _aigne_afs_messaging.BaseMessageProvider {
+	static manifest() {
+		return {
+			name: "discord",
+			description: "Discord Bot API — bidirectional messaging via Gateway WebSocket.\n- Real-time events via Discord Gateway with heartbeat and resume\n- Multi-bot support with per-bot channel monitoring\n- Path: /:bot/conversations/:channelId/messages/:msgId",
+			uriTemplate: "discord://{token}",
+			category: "messaging",
+			schema: {
+				type: "object",
+				properties: {
+					token: {
+						type: "string",
+						description: "Discord Bot token",
+						sensitive: true
+					},
+					channels: {
+						type: "array",
+						items: { type: "string" },
+						description: "Channel IDs to monitor"
+					}
+				},
+				required: ["token"]
+			},
+			tags: [
+				"discord",
+				"messaging",
+				"chat",
+				"bot"
+			],
+			capabilityTags: [
+				"read-write",
+				"crud",
+				"search",
+				"auth:token",
+				"remote",
+				"http",
+				"real-time",
+				"rate-limited"
+			],
+			security: {
+				riskLevel: "external",
+				resourceAccess: ["internet"],
+				notes: ["Connects to Discord API + Gateway — requires bot token with MESSAGE_CONTENT intent"]
+			},
+			capabilities: { network: {
+				egress: true,
+				allowedDomains: ["discord.com", "gateway.discord.gg"]
+			} }
+		};
+	}
+	static treeSchema() {
+		return {
+			operations: [
+				"list",
+				"read",
+				"exec",
+				"stat",
+				"explain"
+			],
+			tree: {
+				"/": {
+					kind: "messaging:root",
+					operations: ["list", "exec"],
+					actions: [
+						"add-bot",
+						"remove-bot",
+						"start",
+						"stop",
+						"process-event"
+					]
+				},
+				"/{bot}": {
+					kind: "messaging:bot",
+					operations: ["list", "read"]
+				},
+				"/{bot}/ctl": {
+					kind: "messaging:status",
+					operations: ["read"]
+				},
+				"/{bot}/conversations": {
+					kind: "messaging:conversations",
+					operations: ["list"]
+				},
+				"/{bot}/conversations/{convId}": {
+					kind: "messaging:conversation",
+					operations: ["list"]
+				},
+				"/{bot}/conversations/{convId}/messages": {
+					kind: "messaging:messages",
+					operations: ["list", "exec"],
+					actions: ["send"]
+				},
+				"/{bot}/conversations/{convId}/messages/{msgId}": {
+					kind: "messaging:message",
+					operations: ["read"]
+				}
+			},
+			auth: {
+				type: "token",
+				env: ["DISCORD_BOT_TOKEN"]
+			},
+			bestFor: [
+				"community chat",
+				"bot commands",
+				"server notifications"
+			],
+			notFor: ["file storage", "database queries"]
+		};
+	}
+	providerName = "discord";
+	eventPrefix = "discord";
+	_gatewayStates = /* @__PURE__ */ new Map();
+	constructor(options) {
+		let bots;
+		if (options.bots) {
+			bots = options.bots;
+			for (const bot of bots) if (!bot.token) throw new Error(`AFSDiscord bot "${bot.name}" requires a token`);
+		} else {
+			if (!options.token) throw new Error("AFSDiscord requires a token");
+			bots = [{
+				name: "default",
+				token: options.token,
+				conversations: options.channels ?? [],
+				apiBase: options.apiBase,
+				intents: options.intents
+			}];
+		}
+		super({
+			bots,
+			bufferSize: options.bufferSize
+		});
+		for (const bot of bots) this._gatewayStates.set(bot.name, {
+			ws: null,
+			connected: false,
+			disposed: false,
+			sessionId: null,
+			resumeUrl: null,
+			seq: null,
+			heartbeatTimer: null,
+			heartbeatAcked: true,
+			backoff: 1e3,
+			intents: bot.intents ?? DEFAULT_INTENTS
+		});
+	}
+	getMessageCapabilities() {
+		return {
+			formats: {
+				send: ["text", "markdown"],
+				receive: ["text"]
+			},
+			maxMessageLength: 2e3,
+			features: {
+				edit: false,
+				delete: false,
+				reply: true,
+				thread: true,
+				reaction: true,
+				inlineKeyboard: false
+			},
+			limits: { messagesPerSecond: 5 }
+		};
+	}
+	createBotClient(config) {
+		return new DiscordClient({
+			token: config.token,
+			apiBase: config.apiBase
+		});
+	}
+	async sendMessage(client, convId, text, _opts) {
+		return { messageId: (await client.sendMessage(convId, text)).id };
+	}
+	async sendTypingIndicator(client, convId) {
+		await client.triggerTyping(convId);
+	}
+	normalizeMessage(raw) {
+		const msg = raw;
+		return {
+			id: msg.id ?? "0",
+			text: String(msg.content ?? ""),
+			from: this.normalizeSender(msg.author),
+			timestamp: msg.timestamp ? Math.floor(new Date(msg.timestamp).getTime() / 1e3) : Math.floor(Date.now() / 1e3),
+			conversationId: String(msg.channel_id ?? ""),
+			platform: { guild_id: msg.guild_id }
+		};
+	}
+	normalizeSender(raw) {
+		return {
+			id: String(raw.id ?? "0"),
+			name: String(raw.username ?? raw.name ?? ""),
+			isBot: raw.bot
+		};
+	}
+	start(botName) {
+		const names = botName ? [botName] : [...this._gatewayStates.keys()];
+		for (const name of names) {
+			const state = this._gatewayStates.get(name);
+			if (!state || state.connected || state.disposed) continue;
+			this._connectGateway(name);
+		}
+	}
+	stop(botName) {
+		const names = botName ? [botName] : [...this._gatewayStates.keys()];
+		for (const name of names) this._disconnectGateway(name);
+	}
+	dispose() {
+		for (const name of this._gatewayStates.keys()) {
+			const state = this._gatewayStates.get(name);
+			state.disposed = true;
+			this._disconnectGateway(name);
+		}
+	}
+	onBotAdded(name) {
+		if (!this._gatewayStates.has(name)) this._gatewayStates.set(name, {
+			ws: null,
+			connected: false,
+			disposed: false,
+			sessionId: null,
+			resumeUrl: null,
+			seq: null,
+			heartbeatTimer: null,
+			heartbeatAcked: true,
+			backoff: 1e3,
+			intents: DEFAULT_INTENTS
+		});
+	}
+	onBotRemoved(name) {
+		this._disconnectGateway(name);
+		this._gatewayStates.delete(name);
+	}
+	async listRootActions(_ctx) {
+		return { data: [
+			this.buildEntry("/.actions/add-bot", { meta: { description: "Add a bot instance at runtime" } }),
+			this.buildEntry("/.actions/remove-bot", { meta: { description: "Remove a bot instance" } }),
+			this.buildEntry("/.actions/start", { meta: { description: "Connect to Discord Gateway" } }),
+			this.buildEntry("/.actions/stop", { meta: { description: "Disconnect from Gateway" } }),
+			this.buildEntry("/.actions/process-event", { meta: { description: "Inject a Discord event externally" } })
+		] };
+	}
+	async execStart(_ctx) {
+		this.start();
+		return {
+			success: true,
+			data: {
+				ok: true,
+				gateway: true
+			}
+		};
+	}
+	async execStop(_ctx) {
+		this.stop();
+		return {
+			success: true,
+			data: {
+				ok: true,
+				gateway: false
+			}
+		};
+	}
+	async execProcessEvent(_ctx, args) {
+		this._processEvent(args);
+		return {
+			success: true,
+			data: { ok: true }
+		};
+	}
+	async _connectGateway(botName) {
+		const state = this._gatewayStates.get(botName);
+		const client = this._getClient(botName);
+		if (!state || !client || state.disposed) return;
+		try {
+			let gatewayUrl = state.resumeUrl;
+			if (!gatewayUrl) gatewayUrl = await client.getGatewayUrl();
+			const wsUrl = `${gatewayUrl}/?v=10&encoding=json`;
+			const ws = new WebSocket(wsUrl);
+			state.ws = ws;
+			ws.onmessage = (event) => {
+				try {
+					const payload = JSON.parse(String(event.data));
+					this._handleGatewayPayload(botName, payload);
+				} catch {}
+			};
+			ws.onclose = () => {
+				this._cleanupGateway(botName);
+				if (!state.disposed) {
+					setTimeout(() => this._connectGateway(botName), state.backoff);
+					state.backoff = Math.min(state.backoff * 2, 6e4);
+				}
+			};
+			ws.onerror = () => {};
+		} catch {
+			if (!state.disposed) {
+				setTimeout(() => this._connectGateway(botName), state.backoff);
+				state.backoff = Math.min(state.backoff * 2, 6e4);
+			}
+		}
+	}
+	_handleGatewayPayload(botName, payload) {
+		const state = this._gatewayStates.get(botName);
+		if (!state) return;
+		if (payload.s !== null) state.seq = payload.s;
+		switch (payload.op) {
+			case GatewayOp.HELLO: {
+				const interval = payload.d?.heartbeat_interval ?? 41250;
+				this._startHeartbeat(botName, interval);
+				if (state.sessionId) this._sendResume(botName);
+				else this._sendIdentify(botName);
+				break;
+			}
+			case GatewayOp.HEARTBEAT_ACK:
+				state.heartbeatAcked = true;
+				break;
+			case GatewayOp.DISPATCH:
+				this._handleDispatch(botName, payload.t, payload.d);
+				break;
+			case GatewayOp.RECONNECT:
+				state.ws?.close();
+				break;
+			case GatewayOp.INVALID_SESSION:
+				if (!(payload.d === true)) {
+					state.sessionId = null;
+					state.seq = null;
+				}
+				setTimeout(() => {
+					state.ws?.close();
+				}, 1e3 + Math.random() * 4e3);
+				break;
+		}
+	}
+	_handleDispatch(botName, eventType, data) {
+		const state = this._gatewayStates.get(botName);
+		if (!state) return;
+		if (eventType === "READY") {
+			state.connected = true;
+			state.sessionId = data.session_id;
+			state.resumeUrl = data.resume_gateway_url ?? null;
+			state.backoff = 1e3;
+			return;
+		}
+		if (eventType === "RESUMED") {
+			state.connected = true;
+			state.backoff = 1e3;
+			return;
+		}
+		if (eventType === "MESSAGE_CREATE") {
+			if (data.author?.bot) return;
+			const channelId = String(data.channel_id ?? "");
+			const text = String(data.content ?? "").trim();
+			if (!text) return;
+			this.emitMessageReceived(botName, {
+				id: String(data.id),
+				text,
+				from: this.normalizeSender({
+					id: data.author?.id,
+					username: data.author?.username,
+					bot: data.author?.bot
+				}),
+				timestamp: data.timestamp ? Math.floor(new Date(data.timestamp).getTime() / 1e3) : Math.floor(Date.now() / 1e3),
+				conversationId: channelId,
+				platform: { guild_id: data.guild_id }
+			});
+		}
+	}
+	_sendIdentify(botName) {
+		const state = this._gatewayStates.get(botName);
+		if (!state?.ws) return;
+		const token = (this._pendingBots?.find((b) => b.name === botName))?.token;
+		if (!token) return;
+		state.ws.send(JSON.stringify({
+			op: GatewayOp.IDENTIFY,
+			d: {
+				token,
+				intents: state.intents,
+				properties: {
+					os: "linux",
+					browser: "afs-discord",
+					device: "afs-discord"
+				}
+			}
+		}));
+	}
+	_sendResume(botName) {
+		const state = this._gatewayStates.get(botName);
+		if (!state?.ws) return;
+		const token = (this._pendingBots?.find((b) => b.name === botName))?.token;
+		if (!token) return;
+		state.ws.send(JSON.stringify({
+			op: GatewayOp.RESUME,
+			d: {
+				token,
+				session_id: state.sessionId,
+				seq: state.seq
+			}
+		}));
+	}
+	_startHeartbeat(botName, intervalMs) {
+		const state = this._gatewayStates.get(botName);
+		if (!state) return;
+		this._stopHeartbeat(botName);
+		state.heartbeatAcked = true;
+		state.heartbeatTimer = setInterval(() => {
+			if (!state.heartbeatAcked) {
+				state.ws?.close();
+				return;
+			}
+			state.heartbeatAcked = false;
+			state.ws?.send(JSON.stringify({
+				op: GatewayOp.HEARTBEAT,
+				d: state.seq
+			}));
+		}, intervalMs);
+	}
+	_stopHeartbeat(botName) {
+		const state = this._gatewayStates.get(botName);
+		if (state?.heartbeatTimer) {
+			clearInterval(state.heartbeatTimer);
+			state.heartbeatTimer = null;
+		}
+	}
+	_disconnectGateway(botName) {
+		const state = this._gatewayStates.get(botName);
+		if (!state) return;
+		this._stopHeartbeat(botName);
+		if (state.ws) {
+			state.ws.onclose = null;
+			state.ws.onmessage = null;
+			state.ws.onerror = null;
+			state.ws.close();
+			state.ws = null;
+		}
+		state.connected = false;
+	}
+	_cleanupGateway(botName) {
+		const state = this._gatewayStates.get(botName);
+		if (!state) return;
+		this._stopHeartbeat(botName);
+		state.ws = null;
+		state.connected = false;
+	}
+	/** Process an externally-provided Discord event (e.g., from interaction endpoint). Public for testing. */
+	_processEvent(payload) {
+		const botName = payload.botName ?? this._botOrder[0] ?? "default";
+		const type = payload.t;
+		const data = payload.d ?? payload;
+		if (type === "MESSAGE_CREATE" || data.content !== void 0) {
+			if (data.author?.bot) return;
+			const channelId = String(data.channel_id ?? "");
+			const text = String(data.content ?? "").trim();
+			if (!text) return;
+			this.emitMessageReceived(botName, {
+				id: String(data.id ?? Date.now()),
+				text,
+				from: this.normalizeSender({
+					id: data.author?.id ?? "0",
+					username: data.author?.username ?? "",
+					bot: data.author?.bot
+				}),
+				timestamp: data.timestamp ? Math.floor(new Date(data.timestamp).getTime() / 1e3) : Math.floor(Date.now() / 1e3),
+				conversationId: channelId,
+				platform: { guild_id: data.guild_id }
+			});
+		}
+	}
+	/** Add a channel to a bot. Defaults to first bot. */
+	addChannel(channelId, botName) {
+		const name = botName ?? this._botOrder[0];
+		if (!name) return;
+		const convs = this._botConversations.get(name);
+		if (!convs || convs.has(channelId)) return;
+		convs.add(channelId);
+		const buffers = this._botBuffers.get(name);
+		if (buffers && !buffers.has(channelId)) buffers.set(channelId, []);
+	}
+	/** Remove a channel from a bot. */
+	removeChannel(channelId, botName) {
+		const name = botName ?? this._botOrder[0];
+		if (!name) return;
+		const convs = this._botConversations.get(name);
+		if (convs) convs.delete(channelId);
+		const buffers = this._botBuffers.get(name);
+		if (buffers) buffers.delete(channelId);
+	}
+	/** Add a message to the ring buffer directly. Public for testing/conformance. */
+	_addToBuffer(channelId, msg) {
+		const botName = this._botOrder[0] ?? "default";
+		const convs = this._botConversations.get(botName);
+		if (convs && !convs.has(channelId)) convs.add(channelId);
+		let botBuffers = this._botBuffers.get(botName);
+		if (!botBuffers) {
+			botBuffers = /* @__PURE__ */ new Map();
+			this._botBuffers.set(botName, botBuffers);
+		}
+		let buffer = botBuffers.get(channelId);
+		if (!buffer) {
+			buffer = [];
+			botBuffers.set(channelId, buffer);
+		}
+		buffer.push({
+			id: msg.id,
+			text: msg.content,
+			from: {
+				id: msg.author.id,
+				name: msg.author.username
+			},
+			timestamp: msg.timestamp ? Math.floor(new Date(msg.timestamp).getTime() / 1e3) : Math.floor(Date.now() / 1e3),
+			conversationId: channelId,
+			platform: {}
+		});
+		while (buffer.length > this._bufferSize) buffer.shift();
+	}
+};
+__decorate([(0, _aigne_afs_provider.Actions)("/")], AFSDiscord.prototype, "listRootActions", null);
+__decorate([_aigne_afs_provider.Actions.Exec("/", "start")], AFSDiscord.prototype, "execStart", null);
+__decorate([_aigne_afs_provider.Actions.Exec("/", "stop")], AFSDiscord.prototype, "execStop", null);
+__decorate([_aigne_afs_provider.Actions.Exec("/", "process-event")], AFSDiscord.prototype, "execProcessEvent", null);
+
+//#endregion
+exports.AFSDiscord = AFSDiscord;