hyperclaw 5.0.0 → 5.0.2

package/dist/connector-B8BK0GBo.js

@@ -0,0 +1,531 @@
+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 crypto = require_chunk.__toESM(require("crypto"));
+const http = require_chunk.__toESM(require("http"));
+const ws = require_chunk.__toESM(require("ws"));
+const https = require_chunk.__toESM(require("https"));
+const events = require_chunk.__toESM(require("events"));
+
+//#region extensions/mattermost/src/connector.ts
+const STATE_FILE = path.default.join(os.default.homedir(), ".hyperclaw", "mattermost-state.json");
+const HMAC_INTERACTIONS_KEY = "openclaw-mattermost-interactions";
+const WS_RECONNECT_DELAY_MS = 5e3;
+async function mmApi(baseUrl, token, method, apiPath, body) {
+	return new Promise((resolve, reject) => {
+		const base = baseUrl.replace(/\/$/, "");
+		const fullPath = apiPath.startsWith("/") ? apiPath : `/${apiPath}`;
+		const url = new URL(fullPath, base);
+		const payload = body ? JSON.stringify(body) : null;
+		const client = url.protocol === "https:" ? https.default : http.default;
+		const req = client.request({
+			hostname: url.hostname,
+			port: url.port || (url.protocol === "https:" ? 443 : 80),
+			path: url.pathname + (url.search || ""),
+			method,
+			headers: {
+				Authorization: `Bearer ${token}`,
+				...payload ? {
+					"Content-Type": "application/json",
+					"Content-Length": Buffer.byteLength(payload)
+				} : {}
+			}
+		}, (res) => {
+			let data = "";
+			res.on("data", (c) => data += c);
+			res.on("end", () => {
+				try {
+					const r = data ? JSON.parse(data) : {};
+					const ok = res.statusCode !== void 0 && res.statusCode >= 200 && res.statusCode < 300;
+					if (ok) resolve(r);
+					else reject(new Error(r.message || r.error || `HTTP ${res.statusCode}`));
+				} catch (e) {
+					reject(e || new Error("Parse error"));
+				}
+			});
+		});
+		req.on("error", reject);
+		if (payload) req.write(payload);
+		req.end();
+	});
+}
+function deriveInteractionSecret(botToken) {
+	return crypto.default.createHmac("sha256", HMAC_INTERACTIONS_KEY).update(botToken).digest("hex");
+}
+function signContext(ctx, secret) {
+	const sortedKeys = Object.keys(ctx).sort();
+	const payload = {};
+	for (const k of sortedKeys) payload[k] = ctx[k];
+	const serialized = JSON.stringify(payload);
+	return crypto.default.createHmac("sha256", secret).update(serialized).digest("hex");
+}
+function verifyInteraction(context, secret) {
+	const token = context["_token"];
+	if (typeof token !== "string") return false;
+	const { _token: _,...rest } = context;
+	return signContext(rest, secret) === token;
+}
+function resolveAccount(id, raw, state) {
+	const botToken = raw.botToken || raw.token || process.env["MATTERMOST_BOT_TOKEN"] || "";
+	const baseUrl = raw.baseUrl || raw.serverUrl || process.env["MATTERMOST_URL"] || "";
+	return {
+		id,
+		name: raw.name ?? id,
+		botToken,
+		baseUrl: baseUrl.replace(/\/$/, ""),
+		dmPolicy: raw.dmPolicy ?? "pairing",
+		allowFrom: raw.allowFrom ?? [],
+		groupPolicy: raw.groupPolicy ?? "allowlist",
+		groupAllowFrom: raw.groupAllowFrom ?? [],
+		dangerouslyAllowNameMatching: raw.dangerouslyAllowNameMatching ?? false,
+		chatmode: raw.chatmode ?? "oncall",
+		oncharPrefixes: raw.oncharPrefixes ?? [">"],
+		requireMention: raw.requireMention ?? true,
+		commands: raw.commands ?? { native: false },
+		capabilities: raw.capabilities ?? [],
+		actions: {
+			reactions: true,
+			...raw.actions
+		},
+		interactions: raw.interactions ?? {},
+		approvedPairings: state.approved,
+		pendingPairings: state.pending
+	};
+}
+var SingleAccountConnector = class extends events.EventEmitter {
+	acc;
+	ws = null;
+	wsSeq = 1;
+	reconnecting = false;
+	botUserId = "";
+	constructor(acc) {
+		super();
+		this.acc = acc;
+	}
+	async connect() {
+		const me = await mmApi(this.acc.baseUrl, this.acc.botToken, "GET", "/api/v4/users/me");
+		this.botUserId = me.id;
+		console.log(chalk.default.green(`  🦅 Mattermost[${this.acc.id}]: connected as @${me.username} → ${this.acc.baseUrl}`));
+		this._startWebSocket();
+		this.emit("connected", {
+			accountId: this.acc.id,
+			baseUrl: this.acc.baseUrl,
+			botUserId: this.botUserId
+		});
+	}
+	disconnect() {
+		this.reconnecting = false;
+		this.ws?.close();
+		this.ws = null;
+	}
+	_startWebSocket() {
+		const wsUrl = this.acc.baseUrl.replace(/^http/, "ws") + "/api/v4/websocket";
+		const ws$1 = new ws.default(wsUrl);
+		this.ws = ws$1;
+		ws$1.on("open", () => {
+			this.wsSeq = 1;
+			ws$1.send(JSON.stringify({
+				seq: this.wsSeq++,
+				action: "authentication_challenge",
+				data: { token: this.acc.botToken }
+			}));
+		});
+		ws$1.on("message", (raw) => {
+			try {
+				const ev = JSON.parse(raw.toString());
+				if (ev.event === "posted") this._onPostedEvent(ev);
+				if (ev.event === "reaction_added" || ev.event === "reaction_removed") this.emit("reaction", {
+					accountId: this.acc.id,
+					event: ev.event,
+					data: ev.data
+				});
+			} catch {}
+		});
+		ws$1.on("close", () => {
+			if (!this.reconnecting) return;
+			console.log(chalk.default.yellow(`  ⚠ Mattermost[${this.acc.id}]: WS closed, reconnecting...`));
+			setTimeout(() => this._startWebSocket(), WS_RECONNECT_DELAY_MS);
+		});
+		ws$1.on("error", (err) => {
+			console.log(chalk.default.yellow(`  ⚠ Mattermost[${this.acc.id}]: WS error: ${err.message}`));
+		});
+		this.reconnecting = true;
+	}
+	_onPostedEvent(ev) {
+		let post;
+		try {
+			post = typeof ev.data?.post === "string" ? JSON.parse(ev.data.post) : ev.data?.post;
+		} catch {
+			return;
+		}
+		if (!post) return;
+		if (post.user_id === this.botUserId) return;
+		const channelType = ev.data?.channel_type ?? "";
+		const isDM = channelType === "D";
+		const text = (post.message || "").trim();
+		const from = post.user_id;
+		const channelId = post.channel_id;
+		const senderName = ev.data?.sender_name ?? "";
+		if (!text) return;
+		if (isDM) this._routeDM(from, channelId, text, senderName, post.id);
+		else this._routeChannel(from, channelId, text, senderName, post.id);
+	}
+	async _routeDM(userId, channelId, text, senderName, postId) {
+		const acc = this.acc;
+		if (acc.dmPolicy === "none") return;
+		if (acc.dmPolicy === "open") {
+			this._emit(userId, channelId, text, senderName, postId, true);
+			return;
+		}
+		if (acc.dmPolicy === "allowlist") {
+			if (!acc.allowFrom.includes(userId)) {
+				console.log(chalk.default.gray(`  mattermost[${acc.id}]: drop DM from ${userId} (dmPolicy=allowlist)`));
+				return;
+			}
+			this._emit(userId, channelId, text, senderName, postId, true);
+			return;
+		}
+		if (acc.dmPolicy === "pairing") {
+			if (acc.approvedPairings.includes(userId)) {
+				this._emit(userId, channelId, text, senderName, postId, true);
+				return;
+			}
+			const upper = text.trim().toUpperCase();
+			if (acc.pendingPairings[upper]) {
+				acc.approvedPairings.push(userId);
+				delete acc.pendingPairings[upper];
+				await this._saveState();
+				await this.sendMessage(channelId, "🦅 Paired!");
+				this.emit("pairing:approved", {
+					accountId: acc.id,
+					userId,
+					channelId
+				});
+				return;
+			}
+			const code = Array.from({ length: 6 }, () => "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"[Math.floor(Math.random() * 32)]).join("");
+			acc.pendingPairings[code] = userId;
+			await this._saveState();
+			await this.sendMessage(channelId, `🦅 Pairing code: \`${code}\`\nApprove: hyperclaw pairing approve mattermost ${code}`);
+		}
+	}
+	_routeChannel(userId, channelId, text, senderName, postId) {
+		const acc = this.acc;
+		if (acc.groupPolicy === "allowlist") {
+			const combined = [...acc.groupAllowFrom, ...acc.allowFrom];
+			if (combined.length > 0) {
+				const match = combined.some((p) => {
+					if (p === "*") return true;
+					if (acc.dangerouslyAllowNameMatching) {
+						const name = senderName.replace(/^@/, "");
+						return name === p || userId === p;
+					}
+					return userId === p;
+				});
+				if (!match) {
+					console.log(chalk.default.gray(`  mattermost[${acc.id}]: drop group sender ${userId} (policy=allowlist)`));
+					return;
+				}
+			}
+		}
+		const botMentionPatterns = [
+			`@${this.botUserId}`,
+			`@hyperclaw`,
+			`@${acc.name?.toLowerCase()}`
+		];
+		const isMentioned = botMentionPatterns.some((p) => text.toLowerCase().includes(p.toLowerCase()));
+		if (acc.chatmode === "oncall" || acc.chatmode !== "onmessage" && acc.requireMention) {
+			if (!isMentioned) {
+				console.log(chalk.default.gray(`  mattermost[${acc.id}]: drop channel ${channelId} (missing-mention, chatmode=oncall)`));
+				return;
+			}
+		} else if (acc.chatmode === "onchar") {
+			const hasPrefix = acc.oncharPrefixes.some((p) => text.startsWith(p));
+			if (!hasPrefix && !isMentioned) {
+				console.log(chalk.default.gray(`  mattermost[${acc.id}]: drop channel ${channelId} (no prefix/mention, chatmode=onchar)`));
+				return;
+			}
+		}
+		this._emit(userId, channelId, text, senderName, postId, false);
+	}
+	_emit(from, chatId, text, senderName, postId, isDM) {
+		this.emit("message", {
+			accountId: this.acc.id,
+			id: postId,
+			from,
+			chatId,
+			text,
+			senderName,
+			isDM,
+			channelId: "mattermost"
+		});
+	}
+	async handleWebhook(body, webhookToken) {
+		let params = {};
+		const trimmed = (body || "").trim();
+		if (trimmed.startsWith("{")) try {
+			params = JSON.parse(trimmed);
+		} catch {
+			return;
+		}
+		else for (const pair of body.split("&")) {
+			const eq = pair.indexOf("=");
+			const k = eq >= 0 ? decodeURIComponent(pair.slice(0, eq).replace(/\+/g, " ")) : decodeURIComponent(pair.replace(/\+/g, " "));
+			const v = eq >= 0 ? decodeURIComponent((pair.slice(eq + 1) || "").replace(/\+/g, " ")) : "";
+			if (k) params[k] = v;
+		}
+		if (params.token !== webhookToken) {
+			console.log(chalk.default.yellow(`  ⚠ Mattermost[${this.acc.id}]: invalid webhook token`));
+			return;
+		}
+		const channelId = params.channel_id;
+		const userId = params.user_id;
+		const senderName = params.user_name || "";
+		let text = (params.text || "").trim();
+		const triggerWord = params.trigger_word || "";
+		if (triggerWord && text.startsWith(triggerWord)) text = text.slice(triggerWord.length).trim();
+		if (!channelId || !userId || !text) return;
+		this._routeChannel(userId, channelId, text, senderName, params.post_id || `${channelId}-${Date.now()}`);
+	}
+	async handleSlashCommand(payload, expectedToken) {
+		if (payload.token !== expectedToken) {
+			console.log(chalk.default.yellow(`  ⚠ Mattermost[${this.acc.id}]: slash command token mismatch`));
+			return null;
+		}
+		const text = (payload.text || "").trim();
+		const userId = payload.user_id || "";
+		const channelId = payload.channel_id || "";
+		const commandName = payload.command || "";
+		this.emit("slash_command", {
+			accountId: this.acc.id,
+			command: commandName,
+			text,
+			userId,
+			channelId,
+			senderName: payload.user_name || "",
+			responseUrl: payload.response_url || ""
+		});
+		return null;
+	}
+	/** Register all native slash commands via Mattermost REST API. */
+	async registerSlashCommands(teamId, commands) {
+		const acc = this.acc;
+		if (!acc.commands.native || acc.commands.native === "auto") return;
+		const callbackUrl = acc.commands.callbackUrl || `http://localhost:18789${acc.commands.callbackPath ?? "/api/channels/mattermost/command"}`;
+		for (const cmd of commands) try {
+			await mmApi(acc.baseUrl, acc.botToken, "POST", "/api/v4/commands", {
+				team_id: teamId,
+				trigger: cmd.trigger.replace(/^\//, ""),
+				method: "P",
+				title: cmd.description,
+				description: cmd.description,
+				url: callbackUrl,
+				username: acc.name ?? "hyperclaw-bot",
+				auto_complete: true,
+				auto_complete_hint: "[prompt]",
+				auto_complete_desc: cmd.description
+			});
+			console.log(chalk.default.gray(`  mattermost[${acc.id}]: registered /${cmd.trigger}`));
+		} catch (e) {
+			console.log(chalk.default.yellow(`  ⚠ mattermost[${acc.id}]: failed to register /${cmd.trigger}: ${e.message}`));
+		}
+	}
+	handleInteraction(context) {
+		const secret = deriveInteractionSecret(this.acc.botToken);
+		if (!verifyInteraction(context, secret)) return {
+			ok: false,
+			error: "invalid _token"
+		};
+		if (!context["action_id"]) return {
+			ok: false,
+			error: "missing action_id in context"
+		};
+		this.emit("interaction", {
+			accountId: this.acc.id,
+			context
+		});
+		return { ok: true };
+	}
+	async addReaction(postId, emoji) {
+		if (!this.acc.actions.reactions) return;
+		const name = emoji.replace(/:/g, "");
+		await mmApi(this.acc.baseUrl, this.acc.botToken, "POST", "/api/v4/reactions", {
+			user_id: this.botUserId,
+			post_id: postId,
+			emoji_name: name
+		});
+	}
+	async removeReaction(postId, emoji) {
+		if (!this.acc.actions.reactions) return;
+		const name = emoji.replace(/:/g, "");
+		await mmApi(this.acc.baseUrl, this.acc.botToken, "DELETE", `/api/v4/users/${this.botUserId}/posts/${postId}/reactions/${name}`);
+	}
+	async sendMessage(channelId, text, attachments) {
+		const chunks = text.match(/.{1,4000}/gs) || [text];
+		let lastPost;
+		for (let i = 0; i < chunks.length; i++) {
+			const body = {
+				channel_id: channelId,
+				message: chunks[i].slice(0, 16383)
+			};
+			if (i === chunks.length - 1 && attachments?.length) body.props = { attachments };
+			lastPost = await mmApi(this.acc.baseUrl, this.acc.botToken, "POST", "/api/v4/posts", body);
+		}
+		return lastPost;
+	}
+	async resolveTarget(target) {
+		if (target.startsWith("channel:")) return {
+			type: "channel",
+			id: target.slice(8)
+		};
+		if (target.startsWith("user:")) {
+			const ch = await this._getDmChannel(target.slice(5));
+			return {
+				type: "dm",
+				id: ch
+			};
+		}
+		if (target.startsWith("@")) {
+			const users = await mmApi(this.acc.baseUrl, this.acc.botToken, "GET", `/api/v4/users?in_team=&per_page=200&page=0`);
+			const username = target.slice(1).toLowerCase();
+			const found = Array.isArray(users) ? users.find((u) => u.username?.toLowerCase() === username) : null;
+			if (!found) throw new Error(`Mattermost: user ${target} not found`);
+			const ch = await this._getDmChannel(found.id);
+			return {
+				type: "dm",
+				id: ch
+			};
+		}
+		if (target.startsWith("#")) {
+			const name = target.slice(1);
+			const ch = await mmApi(this.acc.baseUrl, this.acc.botToken, "GET", `/api/v4/channels/name/${name}`);
+			return {
+				type: "channel",
+				id: ch.id
+			};
+		}
+		return {
+			type: "channel",
+			id: target
+		};
+	}
+	async _getDmChannel(userId) {
+		const ch = await mmApi(this.acc.baseUrl, this.acc.botToken, "POST", "/api/v4/channels/direct", [this.botUserId, userId]);
+		return ch.id;
+	}
+	approvePairing(code) {
+		const upper = code.toUpperCase();
+		if (!this.acc.pendingPairings[upper]) return false;
+		this.acc.approvedPairings.push(this.acc.pendingPairings[upper]);
+		delete this.acc.pendingPairings[upper];
+		this._saveState();
+		return true;
+	}
+	listPendingPairings() {
+		return { ...this.acc.pendingPairings };
+	}
+	async _saveState() {
+		await fs_extra.default.ensureDir(path.default.dirname(STATE_FILE));
+		let state = {};
+		try {
+			state = await fs_extra.default.readJson(STATE_FILE);
+		} catch {}
+		state[this.acc.id] = {
+			approvedPairings: this.acc.approvedPairings,
+			pendingPairings: this.acc.pendingPairings
+		};
+		await fs_extra.default.writeJson(STATE_FILE, state, { spaces: 2 });
+	}
+	async loadState() {
+		try {
+			const state = await fs_extra.default.readJson(STATE_FILE);
+			const s = state[this.acc.id];
+			if (s?.approvedPairings) this.acc.approvedPairings = s.approvedPairings;
+			if (s?.pendingPairings) this.acc.pendingPairings = s.pendingPairings;
+		} catch {}
+	}
+};
+var MattermostConnector = class extends events.EventEmitter {
+	accounts = /* @__PURE__ */ new Map();
+	rawConfig;
+	constructor(config) {
+		super();
+		this.rawConfig = config;
+	}
+	async connect() {
+		const cfg = this.rawConfig;
+		const accountDefs = cfg.accounts ?? { default: cfg };
+		for (const [id, rawAcc] of Object.entries(accountDefs)) {
+			const merged = {
+				...cfg,
+				...rawAcc
+			};
+			const state = {
+				approved: cfg.approvedPairings ?? [],
+				pending: cfg.pendingPairings ?? {}
+			};
+			const acc = resolveAccount(id, merged, state);
+			if (!acc.botToken || !acc.baseUrl) {
+				console.log(chalk.default.yellow(`  ⚠ Mattermost[${id}]: missing botToken or baseUrl — skipping`));
+				continue;
+			}
+			const conn = new SingleAccountConnector(acc);
+			await conn.loadState();
+			conn.on("message", (msg) => this.emit("message", msg));
+			conn.on("connected", (info) => this.emit("connected", info));
+			conn.on("pairing:approved", (info) => this.emit("pairing:approved", info));
+			conn.on("interaction", (info) => this.emit("interaction", info));
+			conn.on("reaction", (info) => this.emit("reaction", info));
+			conn.on("slash_command", (info) => this.emit("slash_command", info));
+			await conn.connect();
+			this.accounts.set(id, conn);
+		}
+	}
+	disconnect() {
+		for (const conn of this.accounts.values()) conn.disconnect();
+		this.accounts.clear();
+	}
+	_acc(accountId = "default") {
+		const conn = this.accounts.get(accountId);
+		if (!conn) throw new Error(`Mattermost: account '${accountId}' not found`);
+		return conn;
+	}
+	async sendMessage(channelId, text, attachments, accountId) {
+		return this._acc(accountId).sendMessage(channelId, text, attachments);
+	}
+	async addReaction(postId, emoji, accountId) {
+		return this._acc(accountId).addReaction(postId, emoji);
+	}
+	async removeReaction(postId, emoji, accountId) {
+		return this._acc(accountId).removeReaction(postId, emoji);
+	}
+	async resolveTarget(target, accountId) {
+		return this._acc(accountId).resolveTarget(target);
+	}
+	handleInteraction(context, accountId) {
+		return this._acc(accountId).handleInteraction(context);
+	}
+	async handleWebhook(body, webhookToken, accountId) {
+		return this._acc(accountId).handleWebhook(body, webhookToken);
+	}
+	async handleSlashCommand(payload, expectedToken, accountId) {
+		return this._acc(accountId).handleSlashCommand(payload, expectedToken);
+	}
+	approvePairing(code, accountId) {
+		return this._acc(accountId).approvePairing(code);
+	}
+	listPendingPairings(accountId) {
+		return this._acc(accountId).listPendingPairings();
+	}
+	getAccountIds() {
+		return Array.from(this.accounts.keys());
+	}
+	isRunning() {
+		return this.accounts.size > 0;
+	}
+};
+
+//#endregion
+exports.MattermostConnector = MattermostConnector;

package/dist/connector-BE9eJs8-.js

@@ -0,0 +1,182 @@
+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 crypto = require_chunk.__toESM(require("crypto"));
+const https = require_chunk.__toESM(require("https"));
+const events = require_chunk.__toESM(require("events"));
+
+//#region extensions/viber/src/connector.ts
+const STATE_FILE = path.default.join(os.default.homedir(), ".hyperclaw", "viber-state.json");
+function viberReq(token, endpoint, body) {
+	return new Promise((resolve, reject) => {
+		const payload = JSON.stringify(body);
+		const req = https.default.request({
+			hostname: "chatapi.viber.com",
+			port: 443,
+			path: `/pa${endpoint}`,
+			method: "POST",
+			headers: {
+				"X-Viber-Auth-Token": token,
+				"Content-Type": "application/json",
+				"Content-Length": Buffer.byteLength(payload)
+			}
+		}, (res) => {
+			let data = "";
+			res.on("data", (c) => data += c);
+			res.on("end", () => {
+				try {
+					const r = JSON.parse(data);
+					if (r.status !== 0) reject(new Error(r.status_message));
+					else resolve(r);
+				} catch {
+					reject(new Error("Invalid JSON"));
+				}
+			});
+		});
+		req.on("error", reject);
+		req.write(payload);
+		req.end();
+	});
+}
+var ViberConnector = class extends events.EventEmitter {
+	config;
+	running = false;
+	constructor(config) {
+		super();
+		this.config = {
+			dmPolicy: "allowlist",
+			allowFrom: [],
+			approvedPairings: [],
+			pendingPairings: {},
+			...config
+		};
+	}
+	async connect() {
+		await viberReq(this.config.authToken, "/set_webhook", {
+			url: this.config.webhookUrl,
+			event_types: [
+				"delivered",
+				"seen",
+				"failed",
+				"subscribed",
+				"unsubscribed",
+				"conversation_started"
+			],
+			send_name: true
+		});
+		const info = await viberReq(this.config.authToken, "/get_account_info", {});
+		await this.loadState();
+		this.running = true;
+		console.log(chalk.default.green(`  🦅 Viber: ${info.name || this.config.botName} connected`));
+		this.emit("connected", { name: info.name });
+	}
+	disconnect() {
+		this.running = false;
+	}
+	verifySignature(body, signature) {
+		const expected = crypto.default.createHmac("sha256", this.config.authToken).update(body).digest("hex");
+		try {
+			return crypto.default.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+		} catch {
+			return false;
+		}
+	}
+	async handleWebhook(body, signature) {
+		if (signature && !this.verifySignature(body, signature)) {
+			console.log(chalk.default.yellow("  ⚠  Viber: invalid signature"));
+			return;
+		}
+		let payload;
+		try {
+			payload = JSON.parse(body);
+		} catch {
+			return;
+		}
+		if (payload.event === "message") {
+			const userId = payload.sender?.id;
+			const text = payload.message?.text;
+			if (!userId || !text) return;
+			const allowed = await this.checkDMPolicy(userId, text);
+			if (!allowed) return;
+			this.emit("message", {
+				id: payload.message_token?.toString(),
+				channelId: "viber",
+				from: userId,
+				chatId: userId,
+				text,
+				senderName: payload.sender?.name,
+				timestamp: new Date(payload.timestamp).toISOString(),
+				isDM: true
+			});
+		}
+		if (payload.event === "conversation_started") await this.sendMessage(payload.user?.id, `🦅 Hi ${payload.user?.name || "there"}! I'm HyperClaw.`);
+	}
+	async checkDMPolicy(from, 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(from)) return true;
+			await this.sendMessage(from, "🦅 HyperClaw: Not on allowlist.");
+			return false;
+		}
+		if (this.config.dmPolicy === "pairing") {
+			if (this.config.approvedPairings.includes(from)) return true;
+			const upper = text.trim().toUpperCase();
+			if (this.config.pendingPairings[upper]) {
+				this.config.approvedPairings.push(from);
+				delete this.config.pendingPairings[upper];
+				await this.saveState();
+				await this.sendMessage(from, "🦅 Paired!");
+				this.emit("pairing:approved", {
+					userId: from,
+					channelId: "viber"
+				});
+				return true;
+			}
+			const code = Array.from({ length: 6 }, () => "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"[Math.floor(Math.random() * 32)]).join("");
+			this.config.pendingPairings[code] = from;
+			await this.saveState();
+			await this.sendMessage(from, `🦅 Pairing code: ${code}\nApprove: hyperclaw pairing approve viber ${code}`);
+			return false;
+		}
+		return false;
+	}
+	async sendMessage(userId, text) {
+		await viberReq(this.config.authToken, "/send_message", {
+			receiver: userId,
+			type: "text",
+			sender: { name: this.config.botName },
+			text: text.slice(0, 7e3)
+		});
+	}
+	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;
+	}
+	async loadState() {
+		try {
+			const s = await fs_extra.default.readJson(STATE_FILE);
+			if (s.p) this.config.pendingPairings = s.p;
+			if (s.a) this.config.approvedPairings = s.a;
+		} catch {}
+	}
+	async saveState() {
+		await fs_extra.default.ensureDir(path.default.dirname(STATE_FILE));
+		await fs_extra.default.writeJson(STATE_FILE, {
+			p: this.config.pendingPairings,
+			a: this.config.approvedPairings
+		}, { spaces: 2 });
+	}
+	isRunning() {
+		return this.running;
+	}
+};
+
+//#endregion
+exports.ViberConnector = ViberConnector;