hyperclaw 4.0.1 → 5.0.0

package/dist/connector-DXTp5PE8.js

@@ -0,0 +1,508 @@
+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 child_process = require_chunk.__toESM(require("child_process"));
+const http = require_chunk.__toESM(require("http"));
+const https = require_chunk.__toESM(require("https"));
+const events = require_chunk.__toESM(require("events"));
+
+//#region extensions/signal/src/connector.ts
+const STATE_DIR = path.default.join(os.default.homedir(), ".hyperclaw");
+const PAIRING_EXPIRY_MS = 60 * 60 * 1e3;
+const SSE_RECONNECT_DELAY_MS = 5e3;
+function cliReq(daemonUrl, method, endpoint, body) {
+	return new Promise((resolve, reject) => {
+		const base = daemonUrl.replace(/\/$/, "");
+		const url = new URL(endpoint.startsWith("/") ? endpoint : `/${endpoint}`, base);
+		const isHttps = url.protocol === "https:";
+		const mod = isHttps ? https.default : http.default;
+		const payload = body ? JSON.stringify(body) : null;
+		const req = mod.request({
+			hostname: url.hostname,
+			port: parseInt(url.port || (isHttps ? "443" : "8080"), 10),
+			path: url.pathname + (url.search || ""),
+			method,
+			headers: payload ? {
+				"Content-Type": "application/json",
+				"Content-Length": Buffer.byteLength(payload)
+			} : {}
+		}, (res) => {
+			let data = "";
+			res.on("data", (c) => data += c.toString());
+			res.on("end", () => {
+				if (!data.trim()) {
+					resolve({});
+					return;
+				}
+				try {
+					resolve(JSON.parse(data));
+				} catch {
+					resolve({ raw: data });
+				}
+			});
+		});
+		req.on("error", reject);
+		if (payload) req.write(payload);
+		req.end();
+	});
+}
+function chunkText(text, limit, mode) {
+	if (mode === "newline") {
+		const paragraphs = text.split(/\n\s*\n/);
+		const result = [];
+		let buf = "";
+		for (const p of paragraphs) if ((buf + (buf ? "\n\n" : "") + p).length > limit) {
+			if (buf) {
+				result.push(buf);
+				buf = "";
+			}
+			if (p.length > limit) {
+				const subs = p.match(new RegExp(`.{1,${limit}}`, "gs")) || [p];
+				result.push(...subs.slice(0, -1));
+				buf = subs[subs.length - 1];
+			} else buf = p;
+		} else buf = buf ? `${buf}\n\n${p}` : p;
+		if (buf) result.push(buf);
+		return result;
+	}
+	return text.match(new RegExp(`.{1,${limit}}`, "gs")) || [text];
+}
+function normalizeSender(source, sourceUuid) {
+	if (sourceUuid) return `uuid:${sourceUuid}`;
+	return source ?? "";
+}
+function senderAllowed(sender, allowList) {
+	if (!allowList.length) return false;
+	return allowList.some((p) => {
+		if (p === "*") return true;
+		if (p === sender) return true;
+		if (p.startsWith("uuid:") && sender === p) return true;
+		if (!p.startsWith("uuid:") && sender === `uuid:${p}`) return true;
+		return false;
+	});
+}
+function resolveAccount(id, raw, state) {
+	const host = raw.httpHost ?? "127.0.0.1";
+	const port = raw.httpPort ?? 8080;
+	const daemonUrl = raw.httpUrl ?? `http://${host}:${port}`;
+	const hasExternalUrl = !!raw.httpUrl;
+	return {
+		id,
+		name: raw.name ?? id,
+		account: raw.account ?? "",
+		cliPath: raw.cliPath ?? "signal-cli",
+		daemonUrl,
+		autoStart: raw.autoStart ?? !hasExternalUrl,
+		startupTimeoutMs: Math.min(raw.startupTimeoutMs ?? 15e3, 12e4),
+		receiveMode: raw.receiveMode ?? "on-start",
+		dmPolicy: raw.dmPolicy ?? "pairing",
+		allowFrom: raw.allowFrom ?? [],
+		groupPolicy: raw.groupPolicy ?? "allowlist",
+		groupAllowFrom: raw.groupAllowFrom ?? [],
+		historyLimit: raw.historyLimit ?? 50,
+		dmHistoryLimit: raw.dmHistoryLimit ?? 50,
+		textChunkLimit: raw.textChunkLimit ?? 4e3,
+		chunkMode: raw.chunkMode ?? "length",
+		mediaMaxMb: raw.mediaMaxMb ?? 8,
+		ignoreAttachments: raw.ignoreAttachments ?? false,
+		ignoreStories: raw.ignoreStories ?? false,
+		sendReadReceipts: raw.sendReadReceipts ?? false,
+		configWrites: raw.configWrites ?? true,
+		actions: {
+			reactions: true,
+			...raw.actions
+		},
+		reactionLevel: raw.reactionLevel ?? "minimal",
+		approvedPairings: state.approved,
+		pendingPairings: state.pending
+	};
+}
+var SingleAccountConnector = class extends events.EventEmitter {
+	acc;
+	daemon = null;
+	sseActive = false;
+	sseReconnect = false;
+	constructor(acc) {
+		super();
+		this.acc = acc;
+	}
+	async connect() {
+		if (this.acc.autoStart) await this._spawnDaemon();
+		await cliReq(this.acc.daemonUrl, "GET", "/v1/accounts");
+		await this._loadState();
+		console.log(chalk.default.green(`  🦅 Signal[${this.acc.id}]: ${this.acc.account || "linked"} connected via ${this.acc.daemonUrl}`));
+		this.emit("connected", {
+			accountId: this.acc.id,
+			account: this.acc.account,
+			daemonUrl: this.acc.daemonUrl
+		});
+		if (this.acc.receiveMode === "on-start") this._startSSE();
+	}
+	disconnect() {
+		this.sseReconnect = false;
+		this.sseActive = false;
+		if (this.daemon) {
+			this.daemon.kill();
+			this.daemon = null;
+		}
+	}
+	async _spawnDaemon() {
+		const { cliPath, account, httpHost, httpPort } = {
+			cliPath: this.acc.cliPath,
+			account: this.acc.account,
+			httpHost: new URL(this.acc.daemonUrl).hostname,
+			httpPort: parseInt(new URL(this.acc.daemonUrl).port || "8080", 10)
+		};
+		if (!account) throw new Error(`Signal[${this.acc.id}]: 'account' (phone number) is required for autoStart`);
+		console.log(chalk.default.gray(`  Signal[${this.acc.id}]: spawning daemon ${cliPath} -a ${account} daemon --http...`));
+		this.daemon = (0, child_process.spawn)(cliPath, [
+			"-a",
+			account,
+			"daemon",
+			"--http",
+			`--port=${httpPort}`,
+			`--http-host=${httpHost}`
+		], {
+			detached: false,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		this.daemon.stderr?.on("data", (d) => {
+			const line = d.toString().trim();
+			if (line) console.log(chalk.default.gray(`  [signal-cli] ${line}`));
+		});
+		this.daemon.on("exit", (code) => {
+			console.log(chalk.default.yellow(`  ⚠ Signal[${this.acc.id}]: daemon exited (code ${code})`));
+		});
+		const deadline = Date.now() + this.acc.startupTimeoutMs;
+		while (Date.now() < deadline) try {
+			await cliReq(this.acc.daemonUrl, "GET", "/v1/accounts");
+			return;
+		} catch {
+			await new Promise((r) => setTimeout(r, 500));
+		}
+		throw new Error(`Signal[${this.acc.id}]: daemon did not start within ${this.acc.startupTimeoutMs}ms`);
+	}
+	_startSSE() {
+		this.sseReconnect = true;
+		this._connectSSE();
+	}
+	_connectSSE() {
+		if (!this.sseReconnect) return;
+		const url = new URL("/v1/events", this.acc.daemonUrl);
+		if (this.acc.account) url.searchParams.set("account", this.acc.account);
+		const isHttps = url.protocol === "https:";
+		const mod = isHttps ? https.default : http.default;
+		const req = mod.request({
+			hostname: url.hostname,
+			port: parseInt(url.port || (isHttps ? "443" : "8080"), 10),
+			path: url.pathname + url.search,
+			method: "GET",
+			headers: {
+				Accept: "text/event-stream",
+				"Cache-Control": "no-cache"
+			}
+		}, (res) => {
+			this.sseActive = true;
+			let buf = "";
+			res.on("data", (chunk) => {
+				buf += chunk.toString();
+				const lines = buf.split("\n");
+				buf = lines.pop() ?? "";
+				let dataLine = "";
+				for (const line of lines) if (line.startsWith("data:")) dataLine = line.slice(5).trim();
+				else if (line === "" && dataLine) {
+					try {
+						this._handleEnvelope(JSON.parse(dataLine));
+					} catch {}
+					dataLine = "";
+				}
+			});
+			res.on("end", () => {
+				this.sseActive = false;
+				if (this.sseReconnect) {
+					console.log(chalk.default.yellow(`  Signal[${this.acc.id}]: SSE disconnected, reconnecting...`));
+					setTimeout(() => this._connectSSE(), SSE_RECONNECT_DELAY_MS);
+				}
+			});
+			res.on("error", () => {
+				this.sseActive = false;
+				if (this.sseReconnect) setTimeout(() => this._connectSSE(), SSE_RECONNECT_DELAY_MS);
+			});
+		});
+		req.on("error", () => {
+			if (this.sseReconnect) setTimeout(() => this._connectSSE(), SSE_RECONNECT_DELAY_MS);
+		});
+		req.end();
+	}
+	_handleEnvelope(ev) {
+		const envelope = ev.envelope ?? ev;
+		if (!envelope) return;
+		if (this.acc.ignoreStories && envelope.storyMessage) return;
+		const dataMessage = envelope.dataMessage ?? envelope.syncMessage?.sentMessage?.dataMessage;
+		if (!dataMessage) return;
+		if (!dataMessage.message && !dataMessage.attachments?.length) return;
+		const source = envelope.source;
+		const sourceUuid = envelope.sourceUuid;
+		const from = normalizeSender(source, sourceUuid);
+		const timestamp = envelope.timestamp ?? Date.now();
+		const msgId = String(timestamp);
+		const text = dataMessage.message?.trim() ?? "";
+		const groupInfo = dataMessage.groupInfo ?? dataMessage.groupV2;
+		if (groupInfo?.groupId) this._routeGroup(from, groupInfo.groupId, text, msgId, dataMessage);
+		else this._routeDM(from, text, msgId, dataMessage);
+	}
+	async _routeDM(from, text, msgId, dataMessage) {
+		const acc = this.acc;
+		if (acc.dmPolicy === "disabled") return;
+		if (acc.sendReadReceipts) this._sendReadReceipt(from, parseInt(msgId, 10)).catch(() => {});
+		if (acc.dmPolicy === "open") {
+			this._emitMessage(from, from, text, msgId, true, void 0, dataMessage);
+			return;
+		}
+		if (acc.dmPolicy === "allowlist") {
+			if (!senderAllowed(from, acc.allowFrom)) {
+				console.log(chalk.default.gray(`  signal[${acc.id}]: drop DM from ${from} (dmPolicy=allowlist)`));
+				return;
+			}
+			this._emitMessage(from, from, text, msgId, true, void 0, dataMessage);
+			return;
+		}
+		if (acc.dmPolicy === "pairing") {
+			const now = Date.now();
+			for (const [code$1, entry] of Object.entries(acc.pendingPairings)) if (entry.expiresAt < now) delete acc.pendingPairings[code$1];
+			if (acc.approvedPairings.includes(from) || senderAllowed(from, acc.allowFrom)) {
+				this._emitMessage(from, from, text, msgId, true, void 0, dataMessage);
+				return;
+			}
+			const upper = text.trim().toUpperCase();
+			const existing = Object.entries(acc.pendingPairings).find(([code$1]) => code$1 === upper);
+			if (existing && existing[1].sender === from) {
+				acc.approvedPairings.push(from);
+				delete acc.pendingPairings[upper];
+				await this._saveState();
+				await this.sendMessage(from, "🦅 Paired!");
+				this.emit("pairing:approved", {
+					accountId: acc.id,
+					sender: from
+				});
+				return;
+			}
+			const code = Array.from({ length: 6 }, () => "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"[Math.floor(Math.random() * 32)]).join("");
+			acc.pendingPairings[code] = {
+				sender: from,
+				expiresAt: now + PAIRING_EXPIRY_MS
+			};
+			await this._saveState();
+			await this.sendMessage(from, `🦅 Pairing code: ${code}\nApprove: hyperclaw pairing approve signal ${code}\n(Expires in 1 hour)`);
+		}
+	}
+	_routeGroup(from, groupId, text, msgId, dataMessage) {
+		const acc = this.acc;
+		if (acc.groupPolicy === "disabled") return;
+		if (acc.groupPolicy === "allowlist") {
+			const combined = [...acc.groupAllowFrom ?? [], ...acc.allowFrom ?? []];
+			if (combined.length && !senderAllowed(from, combined)) {
+				console.log(chalk.default.gray(`  signal[${acc.id}]: drop group msg from ${from} in ${groupId} (allowlist)`));
+				return;
+			}
+		}
+		const chatId = `signal:group:${groupId}`;
+		this._emitMessage(from, chatId, text, msgId, false, groupId, dataMessage);
+	}
+	_emitMessage(from, chatId, text, msgId, isDM, groupId, dataMessage) {
+		const attachments = [];
+		if (!this.acc.ignoreAttachments && Array.isArray(dataMessage?.attachments)) for (const att of dataMessage.attachments) {
+			const sizeMb = (att.size ?? 0) / (1024 * 1024);
+			if (sizeMb <= this.acc.mediaMaxMb) attachments.push(att.id ?? att.filename ?? "");
+		}
+		const payload = {
+			accountId: this.acc.id,
+			id: msgId,
+			from,
+			chatId,
+			text,
+			timestamp: new Date(parseInt(msgId, 10)).toISOString(),
+			isDM,
+			...groupId ? { groupId } : {},
+			...attachments.length ? { attachments } : {}
+		};
+		this.emit("message", payload);
+	}
+	async sendMessage(recipient, text, groupId) {
+		const chunks = chunkText(text, this.acc.textChunkLimit, this.acc.chunkMode);
+		for (const chunk of chunks) {
+			const body = {
+				number: this.acc.account,
+				message: chunk
+			};
+			if (groupId) body.group_id = groupId;
+			else {
+				const resolvedRecipient = recipient.startsWith("uuid:") ? void 0 : recipient;
+				const resolvedUuid = recipient.startsWith("uuid:") ? recipient.slice(5) : void 0;
+				if (resolvedUuid) body.recipients = [{ uuid: resolvedUuid }];
+				else body.recipients = [resolvedRecipient];
+			}
+			await cliReq(this.acc.daemonUrl, "POST", "/v2/send", body);
+		}
+	}
+	async sendTyping(recipient, groupId, stop = false) {
+		try {
+			const body = {
+				number: this.acc.account,
+				stop
+			};
+			if (groupId) body.group_id = groupId;
+			else body.recipient = recipient.startsWith("uuid:") ? { uuid: recipient.slice(5) } : recipient;
+			await cliReq(this.acc.daemonUrl, "PUT", "/v1/typing", body);
+		} catch {}
+	}
+	async _sendReadReceipt(sender, timestamp) {
+		const body = {
+			number: this.acc.account,
+			receipt_type: "read",
+			timestamps: [timestamp]
+		};
+		if (sender.startsWith("uuid:")) body.recipient = { uuid: sender.slice(5) };
+		else body.recipient = sender;
+		await cliReq(this.acc.daemonUrl, "POST", "/v1/receipts", body);
+	}
+	async addReaction(recipient, emoji, targetTimestamp, targetAuthor, groupId) {
+		if (!this.acc.actions.reactions || this.acc.reactionLevel === "off" || this.acc.reactionLevel === "ack") return;
+		const body = {
+			number: this.acc.account,
+			emoji,
+			target_author: targetAuthor ?? recipient,
+			timestamp: targetTimestamp,
+			remove: false
+		};
+		if (groupId) body.group_id = groupId;
+		else body.recipient = recipient.startsWith("uuid:") ? { uuid: recipient.slice(5) } : recipient;
+		await cliReq(this.acc.daemonUrl, "POST", `/v1/reactions/${encodeURIComponent(this.acc.account)}`, body);
+	}
+	async removeReaction(recipient, emoji, targetTimestamp, targetAuthor, groupId) {
+		if (!this.acc.actions.reactions) return;
+		const body = {
+			number: this.acc.account,
+			emoji,
+			target_author: targetAuthor ?? recipient,
+			timestamp: targetTimestamp,
+			remove: true
+		};
+		if (groupId) body.group_id = groupId;
+		else body.recipient = recipient.startsWith("uuid:") ? { uuid: recipient.slice(5) } : recipient;
+		await cliReq(this.acc.daemonUrl, "POST", `/v1/reactions/${encodeURIComponent(this.acc.account)}`, body);
+	}
+	approvePairing(code) {
+		const upper = code.toUpperCase();
+		const entry = this.acc.pendingPairings[upper];
+		if (!entry) return false;
+		if (Date.now() > entry.expiresAt) {
+			delete this.acc.pendingPairings[upper];
+			this._saveState();
+			return false;
+		}
+		this.acc.approvedPairings.push(entry.sender);
+		delete this.acc.pendingPairings[upper];
+		this._saveState();
+		return true;
+	}
+	listPendingPairings() {
+		const now = Date.now();
+		const result = {};
+		for (const [code, entry] of Object.entries(this.acc.pendingPairings)) if (entry.expiresAt > now) result[code] = entry.sender;
+		return result;
+	}
+	_stateFile() {
+		return path.default.join(STATE_DIR, `signal-state-${this.acc.id}.json`);
+	}
+	async _saveState() {
+		await fs_extra.default.ensureDir(STATE_DIR);
+		await fs_extra.default.writeJson(this._stateFile(), {
+			approvedPairings: this.acc.approvedPairings,
+			pendingPairings: this.acc.pendingPairings
+		}, { spaces: 2 });
+	}
+	async _loadState() {
+		try {
+			const s = await fs_extra.default.readJson(this._stateFile());
+			if (Array.isArray(s.approvedPairings)) this.acc.approvedPairings = s.approvedPairings;
+			if (s.pendingPairings && typeof s.pendingPairings === "object") this.acc.pendingPairings = s.pendingPairings;
+		} catch {}
+	}
+};
+var SignalConnector = 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.account && acc.autoStart) {
+				console.log(chalk.default.yellow(`  ⚠ Signal[${id}]: 'account' required for autoStart — 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));
+			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(`Signal: account '${accountId}' not found`);
+		return conn;
+	}
+	async sendMessage(recipient, text, groupId, accountId) {
+		return this._acc(accountId).sendMessage(recipient, text, groupId);
+	}
+	async sendTyping(recipient, groupId, stop, accountId) {
+		return this._acc(accountId).sendTyping(recipient, groupId, stop);
+	}
+	async addReaction(recipient, emoji, targetTimestamp, targetAuthor, groupId, accountId) {
+		return this._acc(accountId).addReaction(recipient, emoji, targetTimestamp, targetAuthor, groupId);
+	}
+	async removeReaction(recipient, emoji, targetTimestamp, targetAuthor, groupId, accountId) {
+		return this._acc(accountId).removeReaction(recipient, emoji, targetTimestamp, targetAuthor, groupId);
+	}
+	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.SignalConnector = SignalConnector;