hyperclaw 5.2.0 → 5.2.2

package/dist/config-D5vF0kvV.js

@@ -0,0 +1,261 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_paths = require('./paths-AIyBxIzm.js');
+const require_paths$1 = require('./paths-DPovhojT.js');
+const require_env_resolve = require('./env-resolve-COjiKYD8.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+
+//#region src/cli/config.ts
+require_paths$1.init_paths();
+require_env_resolve.init_env_resolve();
+const getHC_DIR = () => require_paths.getHyperClawDir();
+const getCFG_FILE = () => require_paths.getConfigPath();
+var ConfigStore = class {
+	/** Load raw config from disk (no hydration). Use for persistence to avoid writing resolved secrets back. */
+	async loadRaw() {
+		try {
+			return await fs_extra.default.readJson(getCFG_FILE());
+		} catch (e) {
+			if (e?.code === "ENOENT") return {};
+			console.error("[config] Failed to load config:", e?.message ?? String(e));
+			throw e;
+		}
+	}
+	/** Load config with env/credentials hydration for runtime use. Do NOT pass the result to save — use patch/save with explicit values only. */
+	async load() {
+		try {
+			const cfg = await fs_extra.default.readJson(getCFG_FILE());
+			if (cfg.channelConfigs) for (const [chId, ch] of Object.entries(cfg.channelConfigs)) {
+				const tok = require_env_resolve.resolveChannelToken(chId, ch?.token || ch?.botToken);
+				if (tok && !ch?.token) ch.token = tok;
+				if (tok && !ch?.botToken) ch.botToken = tok;
+			}
+			if (cfg.provider && !cfg.provider.apiKey) {
+				const key = await require_env_resolve.getProviderCredentialAsync(cfg);
+				if (key) cfg.provider.apiKey = key;
+			}
+			return cfg;
+		} catch (e) {
+			if (e?.code === "ENOENT") return {};
+			console.error("[config] Failed to load config:", e?.message ?? String(e));
+			throw e;
+		}
+	}
+	async save(cfg) {
+		const target = getCFG_FILE();
+		const tmp = target + ".tmp";
+		await fs_extra.default.ensureDir(getHC_DIR());
+		await fs_extra.default.writeJson(tmp, cfg, { spaces: 2 });
+		await fs_extra.default.chmod(tmp, 384);
+		await fs_extra.default.rename(tmp, target);
+	}
+	/** Merge patch into raw config and save. Uses loadRaw() so hydrated secrets from env/store are never written back. */
+	async patch(patch) {
+		const raw = await this.loadRaw();
+		await this.save(deepMerge(raw, patch));
+	}
+	async setProviderKey(providerId, apiKey) {
+		const cfg = await this.load();
+		await this.patch({ provider: {
+			...cfg.provider,
+			providerId,
+			apiKey
+		} });
+		console.log(chalk.default.green(`  ✅ API key saved for ${providerId}`));
+	}
+	async setModel(modelId) {
+		const cfg = await this.load();
+		await this.patch({ provider: {
+			...cfg.provider,
+			modelId
+		} });
+		console.log(chalk.default.green(`  ✅ Model: ${modelId}`));
+	}
+	async setServiceApiKey(serviceId, apiKey) {
+		const cfg = await this.load();
+		const apiKeys = {
+			...cfg.skills?.apiKeys || {},
+			[serviceId]: apiKey
+		};
+		await this.patch({ skills: {
+			...cfg.skills,
+			installed: cfg.skills?.installed || [],
+			apiKeys
+		} });
+		console.log(chalk.default.green(`  ✅ Service API key saved for ${serviceId}`));
+	}
+	async enableChannel(channelId, channelConfig) {
+		const cfg = await this.load();
+		const gwBase = cfg.gateway ?? {
+			port: 18789,
+			bind: "127.0.0.1",
+			authToken: "",
+			runtime: "node",
+			enabledChannels: [],
+			hooks: true,
+			tailscaleExposure: "off"
+		};
+		const channels = gwBase.enabledChannels ?? [];
+		if (!channels.includes(channelId)) channels.push(channelId);
+		const patch = { gateway: {
+			...gwBase,
+			enabledChannels: channels
+		} };
+		if (channelConfig) patch.channelConfigs = {
+			...cfg.channelConfigs,
+			[channelId]: channelConfig
+		};
+		await this.patch(patch);
+		console.log(chalk.default.green(`  ✅ Channel enabled: ${channelId}`));
+	}
+	async disableChannel(channelId) {
+		const cfg = await this.load();
+		const gwBase = cfg.gateway ?? {
+			port: 18789,
+			bind: "127.0.0.1",
+			authToken: "",
+			runtime: "node",
+			enabledChannels: [],
+			hooks: true,
+			tailscaleExposure: "off"
+		};
+		const channels = (gwBase.enabledChannels ?? []).filter((c) => c !== channelId);
+		await this.patch({ gateway: {
+			...gwBase,
+			enabledChannels: channels
+		} });
+		console.log(chalk.default.green(`  ✅ Channel disabled: ${channelId}`));
+	}
+	async setGatewayPort(port) {
+		const cfg = await this.load();
+		const gwBase = cfg.gateway ?? {
+			port: 18789,
+			bind: "127.0.0.1",
+			authToken: "",
+			runtime: "node",
+			enabledChannels: [],
+			hooks: true,
+			tailscaleExposure: "off"
+		};
+		await this.patch({ gateway: {
+			...gwBase,
+			port
+		} });
+	}
+	async setGatewayBind(bind) {
+		const cfg = await this.load();
+		const gwBase = cfg.gateway ?? {
+			port: 18789,
+			bind: "127.0.0.1",
+			authToken: "",
+			runtime: "node",
+			enabledChannels: [],
+			hooks: true,
+			tailscaleExposure: "off"
+		};
+		await this.patch({ gateway: {
+			...gwBase,
+			bind
+		} });
+	}
+	async generateToken() {
+		const token = require("crypto").randomBytes(32).toString("base64url");
+		const cfg = await this.load();
+		const gwBase = cfg.gateway ?? {
+			port: 18789,
+			bind: "127.0.0.1",
+			authToken: "",
+			runtime: "node",
+			enabledChannels: [],
+			hooks: true,
+			tailscaleExposure: "off"
+		};
+		await this.patch({ gateway: {
+			...gwBase,
+			authToken: token
+		} });
+		return token;
+	}
+	async show(scrub = true) {
+		const cfg = await this.load();
+		const display = scrub ? scrubSecrets(cfg) : cfg;
+		console.log(chalk.default.bold.cyan("\n  🦅 HYPERCLAW CONFIGURATION\n"));
+		printSection("Provider", display.provider);
+		printSection("Gateway", display.gateway);
+		printSection("Identity", display.identity);
+		printSection("PC Access", display.pcAccess);
+		if (display.channelConfigs && Object.keys(display.channelConfigs).length > 0) {
+			console.log(chalk.default.bold.white("  Channel Configs:"));
+			for (const [ch, v] of Object.entries(display.channelConfigs)) {
+				const scrubbed = scrubChannelConfig(v);
+				console.log(`    ${chalk.default.cyan(ch)}: ${JSON.stringify(scrubbed).slice(0, 80)}`);
+			}
+			console.log();
+		}
+		if (display.skills?.installed?.length) {
+			console.log(chalk.default.bold.white("  Skills:"));
+			display.skills.installed.forEach((s) => console.log(`    • ${s}`));
+			console.log();
+		}
+		console.log(chalk.default.gray(`  Config file: ${getCFG_FILE()}`));
+		console.log();
+	}
+};
+function deepMerge(base, patch) {
+	const result = { ...base };
+	for (const key of Object.keys(patch || {})) {
+		if (patch[key] === void 0) continue;
+		if (patch[key] !== null && typeof patch[key] === "object" && !Array.isArray(patch[key])) result[key] = deepMerge(base[key] || {}, patch[key]);
+		else result[key] = patch[key];
+	}
+	return result;
+}
+function scrubSecrets(cfg) {
+	const s = JSON.parse(JSON.stringify(cfg));
+	if (s.provider?.apiKey) s.provider.apiKey = "●●●●●●●●";
+	if (Array.isArray(s.providers)) for (const p of s.providers) {
+		if (p.apiKey) p.apiKey = "●●●●●●●●";
+		if (Array.isArray(p.apiKeys)) p.apiKeys = p.apiKeys.map(() => "●●●●●●●●");
+	}
+	if (s.gateway?.authToken) s.gateway.authToken = "●●●●●●●●";
+	if (s.gateway?.remote?.token) s.gateway.remote.token = "●●●●●●●●";
+	if (s.gateway?.remote?.password) s.gateway.remote.password = "●●●●●●●●";
+	if (s.talkMode?.apiKey) s.talkMode.apiKey = "●●●●●●●●";
+	if (s.skills?.apiKeys) {
+		const keys = Object.keys(s.skills.apiKeys);
+		s.skills.apiKeys = Object.fromEntries(keys.map((k) => [k, "●●●●●●●●"]));
+	}
+	return s;
+}
+function scrubChannelConfig(ch) {
+	const s = { ...ch };
+	const secretFields = [
+		"token",
+		"accessToken",
+		"apiKey",
+		"appSecret",
+		"appPassword",
+		"signingSecret",
+		"channelSecret",
+		"secretKey",
+		"password",
+		"verifyToken"
+	];
+	for (const f of secretFields) if (s[f]) s[f] = "●●●●●●●●";
+	return s;
+}
+function printSection(label, data) {
+	if (!data || Object.keys(data).length === 0) return;
+	console.log(chalk.default.bold.white(`  ${label}:`));
+	for (const [k, v] of Object.entries(data)) if (Array.isArray(v)) console.log(`    ${chalk.default.gray(k)}: ${v.join(", ") || "(none)"}`);
+	else console.log(`    ${chalk.default.gray(k)}: ${v}`);
+	console.log();
+}
+
+//#endregion
+Object.defineProperty(exports, 'ConfigStore', {
+  enumerable: true,
+  get: function () {
+    return ConfigStore;
+  }
+});

package/dist/config-D_6MxFk3.js

@@ -0,0 +1,7 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+require('./paths-AIyBxIzm.js');
+require('./paths-DPovhojT.js');
+require('./env-resolve-COjiKYD8.js');
+const require_config = require('./config-D5vF0kvV.js');
+
+exports.ConfigStore = require_config.ConfigStore;

package/dist/config-b2HmFrBr.js

@@ -0,0 +1,7 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+require('./paths-AIyBxIzm.js');
+require('./paths-DPovhojT.js');
+require('./env-resolve-COjiKYD8.js');
+const require_config = require('./config-BEz4yNRx.js');
+
+exports.ConfigStore = require_config.ConfigStore;

package/dist/connector-1H0OW1h8.js

@@ -0,0 +1,419 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const os = require_chunk.__toESM(require("os"));
+const ws = require_chunk.__toESM(require("ws"));
+const https = require_chunk.__toESM(require("https"));
+const events = require_chunk.__toESM(require("events"));
+
+//#region extensions/discord/src/connector.ts
+const STATE_FILE = path.default.join(os.default.homedir(), ".hyperclaw", "discord-state.json");
+const OPC = {
+	DISPATCH: 0,
+	HEARTBEAT: 1,
+	IDENTIFY: 2,
+	RESUME: 6,
+	RECONNECT: 7,
+	INVALID_SESSION: 9,
+	HELLO: 10,
+	HEARTBEAT_ACK: 11
+};
+const INTENTS = {
+	GUILDS: 1,
+	GUILD_MESSAGES: 512,
+	GUILD_MESSAGE_CONTENT: 32768,
+	DIRECT_MESSAGES: 4096,
+	DIRECT_MESSAGE_CONTENT: 16384
+};
+function discordRest(token, method, endpoint, body) {
+	return new Promise((resolve, reject) => {
+		const payload = body ? JSON.stringify(body) : null;
+		const req = https.default.request({
+			hostname: "discord.com",
+			port: 443,
+			path: `/api/v10${endpoint}`,
+			method,
+			headers: {
+				"Authorization": `Bot ${token}`,
+				"User-Agent": "HyperClaw/5.0.0 (https://hyperclaw.ai)",
+				...payload ? {
+					"Content-Type": "application/json",
+					"Content-Length": Buffer.byteLength(payload)
+				} : {}
+			}
+		}, (res) => {
+			let data = "";
+			res.on("data", (c) => data += c);
+			res.on("end", () => {
+				if (res.statusCode === 204) return resolve(null);
+				try {
+					const r = JSON.parse(data);
+					if (res.statusCode && res.statusCode >= 400) reject(new Error(`Discord API ${res.statusCode}: ${r.message || data}`));
+					else resolve(r);
+				} catch {
+					reject(new Error(`Invalid JSON (${res.statusCode})`));
+				}
+			});
+		});
+		req.on("error", reject);
+		if (payload) req.write(payload);
+		req.end();
+	});
+}
+var DiscordConnector = class extends events.EventEmitter {
+	token;
+	config;
+	ws = null;
+	heartbeatInterval = null;
+	lastSequence = null;
+	sessionId = null;
+	resumeGatewayUrl = null;
+	running = false;
+	botUser = null;
+	constructor(token, config) {
+		super();
+		this.token = token;
+		this.config = {
+			token,
+			dmPolicy: "allowlist",
+			allowFrom: [],
+			approvedPairings: [],
+			pendingPairings: {},
+			listenGuildIds: [],
+			commandPrefix: "!",
+			...config
+		};
+	}
+	async connect() {
+		const gateway = await discordRest(this.token, "GET", "/gateway/bot");
+		const wsUrl = (gateway.url || "wss://gateway.discord.gg") + "/?v=10&encoding=json";
+		this.botUser = await discordRest(this.token, "GET", "/users/@me");
+		console.log(chalk.default.green(`  🦅 Discord: @${this.botUser?.username} connected`));
+		await this.loadState();
+		this.running = true;
+		await this.openWebSocket(wsUrl);
+	}
+	async disconnect() {
+		this.running = false;
+		if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
+		this.ws?.close(1e3);
+		await this.saveState();
+	}
+	async openWebSocket(url) {
+		this.ws = new ws.WebSocket(url, { headers: { "User-Agent": "HyperClaw/5.0.0" } });
+		this.ws.on("message", async (data) => {
+			const payload = JSON.parse(data.toString());
+			await this.handlePayload(payload);
+		});
+		this.ws.on("close", (code) => {
+			if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
+			if (!this.running) return;
+			const resumable = ![
+				1e3,
+				4004,
+				4010,
+				4011,
+				4012,
+				4013,
+				4014
+			].includes(code);
+			console.log(chalk.default.yellow(`  ⚠  Discord WS closed (${code}) — ${resumable ? "resuming" : "reconnecting"} in 5s`));
+			setTimeout(() => {
+				if (this.running) {
+					const url$1 = resumable && this.resumeGatewayUrl ? this.resumeGatewayUrl + "/?v=10&encoding=json" : "wss://gateway.discord.gg/?v=10&encoding=json";
+					this.openWebSocket(url$1);
+				}
+			}, 5e3);
+		});
+		this.ws.on("error", (e) => console.log(chalk.default.yellow(`  ⚠  Discord WS error: ${e.message}`)));
+	}
+	async handlePayload(payload) {
+		const { op, d, s, t } = payload;
+		if (s !== null && s !== void 0) this.lastSequence = s;
+		switch (op) {
+			case OPC.HELLO:
+				this.startHeartbeat(d.heartbeat_interval);
+				if (this.sessionId && this.lastSequence) this.resume();
+				else this.identify();
+				break;
+			case OPC.HEARTBEAT_ACK: break;
+			case OPC.HEARTBEAT:
+				this.sendWs({
+					op: OPC.HEARTBEAT,
+					d: this.lastSequence
+				});
+				break;
+			case OPC.RECONNECT:
+				this.ws?.close(4e3);
+				break;
+			case OPC.INVALID_SESSION:
+				if (d) setTimeout(() => this.resume(), 2e3);
+				else {
+					this.sessionId = null;
+					this.lastSequence = null;
+					setTimeout(() => this.identify(), 2e3);
+				}
+				break;
+			case OPC.DISPATCH:
+				await this.handleEvent(t, d);
+				break;
+		}
+	}
+	identify() {
+		const intents = INTENTS.GUILDS | INTENTS.GUILD_MESSAGES | INTENTS.GUILD_MESSAGE_CONTENT | INTENTS.DIRECT_MESSAGES;
+		this.sendWs({
+			op: OPC.IDENTIFY,
+			d: {
+				token: this.token,
+				intents,
+				properties: {
+					os: process.platform,
+					browser: "HyperClaw",
+					device: "HyperClaw"
+				}
+			}
+		});
+	}
+	resume() {
+		this.sendWs({
+			op: OPC.RESUME,
+			d: {
+				token: this.token,
+				session_id: this.sessionId,
+				seq: this.lastSequence
+			}
+		});
+	}
+	startHeartbeat(interval) {
+		if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
+		this.heartbeatInterval = setInterval(() => {
+			this.sendWs({
+				op: OPC.HEARTBEAT,
+				d: this.lastSequence
+			});
+		}, interval);
+	}
+	sendWs(payload) {
+		if (this.ws?.readyState === ws.WebSocket.OPEN) this.ws.send(JSON.stringify(payload));
+	}
+	async handleEvent(type, data) {
+		switch (type) {
+			case "READY":
+				this.sessionId = data.session_id;
+				this.resumeGatewayUrl = data.resume_gateway_url;
+				this.botUser = data.user;
+				await this.saveState();
+				if (this.config.slashCommands !== false) this.registerSlashCommands().catch((e) => console.log(chalk.default.yellow(`  Discord slash commands: ${e.message}`)));
+				this.emit("ready", data.user);
+				break;
+			case "RESUMED":
+				console.log(chalk.default.gray("  Discord session resumed"));
+				break;
+			case "INTERACTION_CREATE":
+				await this.handleInteraction(data);
+				break;
+			case "MESSAGE_CREATE":
+				await this.handleMessage(data);
+				break;
+		}
+	}
+	async handleMessage(msg) {
+		if (msg.author.id === this.botUser?.id) return;
+		if (msg.author.bot) return;
+		const isDM = !msg.channel_id.startsWith("0") && await this.isDirectMessage(msg.channel_id);
+		const userId = msg.author.id;
+		if (isDM) {
+			const allowed = await this.checkDMPolicy(userId, msg.channel_id, msg.content);
+			if (!allowed) return;
+		} else {
+			const guildAllowed = await this.checkGuildPolicy(msg);
+			if (!guildAllowed) return;
+		}
+		this.emit("message", {
+			id: msg.id,
+			channelId: "discord",
+			from: userId,
+			fromUsername: msg.author.global_name || msg.author.username,
+			chatId: msg.channel_id,
+			text: msg.content,
+			timestamp: msg.timestamp,
+			isDM
+		});
+	}
+	dmChannelCache = /* @__PURE__ */ new Set();
+	async isDirectMessage(channelId) {
+		if (this.dmChannelCache.has(channelId)) return true;
+		try {
+			const channel = await discordRest(this.token, "GET", `/channels/${channelId}`);
+			if (channel.type === 1) {
+				this.dmChannelCache.add(channelId);
+				return true;
+			}
+		} catch {}
+		return false;
+	}
+	async checkGuildPolicy(msg) {
+		const channelId = msg.channel_id;
+		let guildId;
+		try {
+			const ch = await discordRest(this.token, "GET", `/channels/${channelId}`);
+			guildId = ch.guild_id;
+		} catch {
+			return false;
+		}
+		if (!guildId) return false;
+		if (this.config.listenGuildIds.length > 0 && !this.config.listenGuildIds.includes(guildId)) return false;
+		if (this.config.requireMentionInGuild !== false) {
+			const content = msg.content || "";
+			const mentioned = msg.mentions?.some((m) => m.id === this.botUser?.id) ?? false;
+			const botMention = this.botUser ? `<@${this.botUser.id}>` : "";
+			if (!mentioned && !content.includes(botMention) && !msg.referenced_message?.author?.bot) return false;
+		}
+		return true;
+	}
+	async checkDMPolicy(userId, channelId, text) {
+		if (this.config.dmPolicy === "none") return false;
+		if (this.config.dmPolicy === "open") return true;
+		if (this.config.dmPolicy === "allowlist") {
+			if (this.config.allowFrom.includes(userId)) return true;
+			await this.sendMessage(channelId, "🦅 **HyperClaw**\n\nYou are not on the allowlist.");
+			return false;
+		}
+		if (this.config.dmPolicy === "pairing") {
+			const bridge = this.config.pairingBridge;
+			if (bridge) {
+				if (await bridge.isApproved(userId)) return true;
+				const upper$1 = text.trim().toUpperCase().replace(/\s/g, "");
+				if (upper$1.length >= 6 && upper$1.length <= 10) {
+					const verified = await bridge.verify(upper$1, userId);
+					if (verified) {
+						await this.sendMessage(channelId, "🦅 **Paired!** You can now send messages.");
+						this.emit("pairing:approved", {
+							userId,
+							channelId: "discord"
+						});
+						return true;
+					}
+				}
+				const code$1 = await bridge.createRequest(userId);
+				if (code$1) await this.sendMessage(channelId, `🦅 **HyperClaw Pairing**\n\nSend the owner this code:\n\`${code$1}\`\n\nApprove with:\n\`hyperclaw pairing approve discord ${code$1}\``);
+				else await this.sendMessage(channelId, "🦅 **HyperClaw Pairing**\n\nYou already have a pending request. Check with the owner to approve.");
+				return false;
+			}
+			if (this.config.approvedPairings.includes(userId)) return true;
+			const upper = text.trim().toUpperCase();
+			if (this.config.pendingPairings[upper]) {
+				this.config.approvedPairings.push(userId);
+				delete this.config.pendingPairings[upper];
+				await this.saveState();
+				await this.sendMessage(channelId, "🦅 **Paired!** You can now send messages.");
+				this.emit("pairing:approved", {
+					userId,
+					channelId: "discord"
+				});
+				return true;
+			}
+			const code = this.generateCode();
+			this.config.pendingPairings[code] = userId;
+			await this.saveState();
+			await this.sendMessage(channelId, `🦅 **HyperClaw Pairing**\n\nSend the owner this code:\n\`${code}\`\n\nApprove with:\n\`hyperclaw pairing approve discord ${code}\``);
+			return false;
+		}
+		return false;
+	}
+	async registerSlashCommands() {
+		const app = await discordRest(this.token, "GET", "/oauth2/applications/@me");
+		const appId = app.id;
+		if (!appId) return;
+		const commands = [{
+			name: "help",
+			description: "Show HyperClaw help and commands"
+		}, {
+			name: "status",
+			description: "Show gateway status"
+		}];
+		await discordRest(this.token, "PUT", `/applications/${appId}/commands`, commands);
+	}
+	async handleInteraction(interaction) {
+		const { id, token, type, data } = interaction;
+		if (type !== 2 || !data?.name) return;
+		const name = data.name;
+		let content = "";
+		if (name === "help") content = "🦅 **HyperClaw** — AI agent on Discord.\n\n**Commands:** `/help`, `/status`\n**Chat:** Just send a message (DM or @mention in servers).\n**Pairing:** DM the bot to get a pairing code, then run `hyperclaw pairing approve discord <CODE>` on the host.";
+		else if (name === "status") content = "🦅 **HyperClaw** — gateway connected. Send a message to chat with the agent.";
+		else return;
+		const payload = {
+			type: 4,
+			data: {
+				content,
+				flags: 64
+			}
+		};
+		await discordRest(this.token, "POST", `/interactions/${id}/${token}/callback`, payload);
+	}
+	async sendMessage(channelId, content) {
+		const chunks = content.match(/.{1,2000}/gs) || [content];
+		let last = null;
+		for (const chunk of chunks) last = await discordRest(this.token, "POST", `/channels/${channelId}/messages`, { content: chunk });
+		return last;
+	}
+	async sendTyping(channelId) {
+		await discordRest(this.token, "POST", `/channels/${channelId}/typing`).catch(() => {});
+	}
+	async createDMChannel(userId) {
+		const ch = await discordRest(this.token, "POST", "/users/@me/channels", { recipient_id: userId });
+		return ch.id;
+	}
+	async sendDM(userId, content) {
+		const channelId = await this.createDMChannel(userId);
+		await this.sendMessage(channelId, content);
+	}
+	generateCode() {
+		const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+		return Array.from({ length: 6 }, () => chars[Math.floor(Math.random() * chars.length)]).join("");
+	}
+	approvePairing(code) {
+		const upper = code.toUpperCase();
+		if (!this.config.pendingPairings[upper]) return false;
+		this.config.approvedPairings.push(this.config.pendingPairings[upper]);
+		delete this.config.pendingPairings[upper];
+		this.saveState();
+		return true;
+	}
+	addToAllowlist(userId) {
+		if (!this.config.allowFrom.includes(userId)) {
+			this.config.allowFrom.push(userId);
+			this.saveState();
+		}
+	}
+	async loadState() {
+		try {
+			const s = await fs_extra.default.readJson(STATE_FILE);
+			this.sessionId = s.sessionId || null;
+			this.lastSequence = s.lastSequence || null;
+			this.resumeGatewayUrl = s.resumeGatewayUrl || null;
+			if (s.pendingPairings) this.config.pendingPairings = s.pendingPairings;
+			if (s.approvedPairings) this.config.approvedPairings = s.approvedPairings;
+		} catch {}
+	}
+	async saveState() {
+		await fs_extra.default.ensureDir(path.default.dirname(STATE_FILE));
+		await fs_extra.default.writeJson(STATE_FILE, {
+			sessionId: this.sessionId,
+			lastSequence: this.lastSequence,
+			resumeGatewayUrl: this.resumeGatewayUrl,
+			pendingPairings: this.config.pendingPairings,
+			approvedPairings: this.config.approvedPairings
+		}, { spaces: 2 });
+	}
+	isRunning() {
+		return this.running;
+	}
+	getBotUser() {
+		return this.botUser;
+	}
+};
+
+//#endregion
+exports.DiscordConnector = DiscordConnector;