@nextclaw/channel-extension-weixin 0.1.1

package/dist/services/weixin-media-part-reader.service.js

@@ -0,0 +1,192 @@
+import { basename, extname } from "node:path";
+import { readFile } from "node:fs/promises";
+//#region src/services/weixin-media-part-reader.service.ts
+const IMAGE_FILE_EXTENSIONS = new Set([
+	".avif",
+	".bmp",
+	".gif",
+	".heic",
+	".jpeg",
+	".jpg",
+	".png",
+	".svg",
+	".webp"
+]);
+function readString(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function normalizeMimeType(value) {
+	if (!value) return;
+	const [mimeType] = value.split(";", 1);
+	return mimeType?.trim().toLowerCase() || void 0;
+}
+function mimeTypeToExtension(mimeType) {
+	switch (mimeType) {
+		case "image/png": return ".png";
+		case "image/jpeg": return ".jpg";
+		case "image/gif": return ".gif";
+		case "image/webp": return ".webp";
+		case "image/svg+xml": return ".svg";
+		case "application/pdf": return ".pdf";
+		default: return ".bin";
+	}
+}
+function isImageMimeType(mimeType) {
+	return Boolean(mimeType?.startsWith("image/"));
+}
+function readPngDimensions(bytes) {
+	if (bytes.byteLength < 24) return null;
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const signature = view.getUint32(0);
+	const ihdr = view.getUint32(12);
+	if (signature !== 2303741511 || ihdr !== 1229472850) return null;
+	return {
+		width: view.getUint32(16),
+		height: view.getUint32(20)
+	};
+}
+function readGifDimensions(bytes) {
+	if (bytes.byteLength < 10) return null;
+	const header = Buffer.from(bytes.subarray(0, 6)).toString("ascii");
+	if (header !== "GIF87a" && header !== "GIF89a") return null;
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	return {
+		width: view.getUint16(6, true),
+		height: view.getUint16(8, true)
+	};
+}
+function readJpegDimensions(bytes) {
+	if (bytes.byteLength < 4 || bytes[0] !== 255 || bytes[1] !== 216) return null;
+	let offset = 2;
+	while (offset + 9 < bytes.byteLength) {
+		if (bytes[offset] !== 255) {
+			offset += 1;
+			continue;
+		}
+		const marker = bytes[offset + 1];
+		offset += 2;
+		if (marker === 216 || marker === 217) continue;
+		if (offset + 2 > bytes.byteLength) return null;
+		const length = bytes[offset] << 8 | bytes[offset + 1];
+		if (length < 2 || offset + length > bytes.byteLength) return null;
+		if (marker >= 192 && marker <= 195 || marker >= 197 && marker <= 199 || marker >= 201 && marker <= 203 || marker >= 205 && marker <= 207) return {
+			height: bytes[offset + 3] << 8 | bytes[offset + 4],
+			width: bytes[offset + 5] << 8 | bytes[offset + 6]
+		};
+		offset += length;
+	}
+	return null;
+}
+function readWebpDimensions(bytes) {
+	if (bytes.byteLength < 30) return null;
+	const header = Buffer.from(bytes.subarray(0, 4)).toString("ascii");
+	const webp = Buffer.from(bytes.subarray(8, 12)).toString("ascii");
+	if (header !== "RIFF" || webp !== "WEBP") return null;
+	const chunk = Buffer.from(bytes.subarray(12, 16)).toString("ascii");
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	if (chunk === "VP8X" && bytes.byteLength >= 30) return {
+		width: 1 + (bytes[24] | bytes[25] << 8 | bytes[26] << 16),
+		height: 1 + (bytes[27] | bytes[28] << 8 | bytes[29] << 16)
+	};
+	if (chunk === "VP8 " && bytes.byteLength >= 30) return {
+		width: view.getUint16(26, true) & 16383,
+		height: view.getUint16(28, true) & 16383
+	};
+	if (chunk === "VP8L" && bytes.byteLength >= 25) {
+		const bits = bytes[21] | bytes[22] << 8 | bytes[23] << 16 | bytes[24] << 24;
+		return {
+			width: (bits & 16383) + 1,
+			height: (bits >> 14 & 16383) + 1
+		};
+	}
+	return null;
+}
+function readImageDimensions(bytes) {
+	return readPngDimensions(bytes) ?? readGifDimensions(bytes) ?? readJpegDimensions(bytes) ?? readWebpDimensions(bytes);
+}
+function readFileNameFromUrl(url) {
+	try {
+		return basename(new URL(url).pathname).trim() || void 0;
+	} catch {
+		return basename(url).trim() || void 0;
+	}
+}
+function resolveFetchUrl(url) {
+	try {
+		return new URL(url).toString();
+	} catch {
+		const endpoint = process.env.NEXTCLAW_EXTENSION_ENDPOINT?.trim();
+		if (!endpoint) return url;
+		return new URL(url, endpoint.endsWith("/") ? endpoint : `${endpoint}/`).toString();
+	}
+}
+var WeixinMediaPartReader = class {
+	read = async (target, part) => {
+		if (part.contentBase64) {
+			const bytes = Buffer.from(part.contentBase64, "base64");
+			const mimeType = normalizeMimeType(part.mimeType);
+			const fileName = this.resolveFileName(part, mimeType);
+			const imageDimensions = this.resolveImageDimensions(bytes, fileName, mimeType);
+			return {
+				bytes,
+				fileName,
+				mimeType,
+				isImage: this.isImageFile(fileName, mimeType),
+				imageWidth: imageDimensions?.width,
+				imageHeight: imageDimensions?.height
+			};
+		}
+		if (part.assetUri) {
+			const contentPath = target.resolveAssetContentPath?.(part.assetUri)?.trim();
+			if (contentPath) {
+				const bytes = await readFile(contentPath);
+				const mimeType = normalizeMimeType(part.mimeType);
+				const fileName = this.resolveFileName(part, mimeType, basename(contentPath));
+				const imageDimensions = this.resolveImageDimensions(bytes, fileName, mimeType);
+				return {
+					bytes,
+					fileName,
+					mimeType,
+					isImage: this.isImageFile(fileName, mimeType),
+					imageWidth: imageDimensions?.width,
+					imageHeight: imageDimensions?.height
+				};
+			}
+			if (!part.url) throw new Error(`weixin send failed: asset "${part.assetUri}" is not readable`);
+		}
+		if (part.url) {
+			const response = await fetch(resolveFetchUrl(part.url));
+			if (!response.ok) throw new Error(`weixin send failed: unable to download ${part.url} (${response.status})`);
+			const bytes = new Uint8Array(await response.arrayBuffer());
+			const mimeType = normalizeMimeType(part.mimeType) ?? normalizeMimeType(response.headers.get("content-type") ?? void 0);
+			const fileName = this.resolveFileName(part, mimeType, readFileNameFromUrl(part.url));
+			const imageDimensions = this.resolveImageDimensions(bytes, fileName, mimeType);
+			return {
+				bytes,
+				fileName,
+				mimeType,
+				isImage: this.isImageFile(fileName, mimeType),
+				imageWidth: imageDimensions?.width,
+				imageHeight: imageDimensions?.height
+			};
+		}
+		throw new Error("weixin send failed: file part is missing content");
+	};
+	resolveFileName = (part, mimeType, fallbackName) => {
+		const explicitName = readString(part.name);
+		if (explicitName) return explicitName;
+		if (fallbackName) return fallbackName;
+		return `attachment${mimeTypeToExtension(mimeType)}`;
+	};
+	isImageFile = (fileName, mimeType) => {
+		if (isImageMimeType(mimeType)) return true;
+		return IMAGE_FILE_EXTENSIONS.has(extname(fileName).toLowerCase());
+	};
+	resolveImageDimensions = (bytes, fileName, mimeType) => {
+		if (!this.isImageFile(fileName, mimeType)) return null;
+		return readImageDimensions(bytes);
+	};
+};
+//#endregion
+export { WeixinMediaPartReader };

package/dist/services/weixin-reply-chat.service.js

@@ -0,0 +1,141 @@
+import { sendWeixinFileMessage, sendWeixinImageMessage } from "../utils/weixin-media.utils.js";
+import { WeixinMediaPartReader } from "./weixin-media-part-reader.service.js";
+import "@nextclaw/ncp-toolkit";
+import { NcpEventType } from "@nextclaw/ncp";
+//#region src/services/weixin-reply-chat.service.ts
+const TERMINAL_NCP_EVENT_TYPES = new Set([
+	NcpEventType.MessageCompleted,
+	NcpEventType.MessageFailed,
+	NcpEventType.RunFinished,
+	NcpEventType.RunError
+]);
+var NcpEventQueue = class {
+	events = [];
+	waiting = null;
+	closed = false;
+	push = (event) => {
+		if (this.closed) return;
+		const waiting = this.waiting;
+		if (waiting) {
+			this.waiting = null;
+			waiting({
+				value: event,
+				done: false
+			});
+			return;
+		}
+		this.events.push(event);
+	};
+	close = () => {
+		this.closed = true;
+		const waiting = this.waiting;
+		if (waiting) {
+			this.waiting = null;
+			waiting({
+				value: void 0,
+				done: true
+			});
+		}
+	};
+	[Symbol.asyncIterator] = () => ({ next: async () => {
+		const event = this.events.shift();
+		if (event) return {
+			value: event,
+			done: false
+		};
+		if (this.closed) return {
+			value: void 0,
+			done: true
+		};
+		return await new Promise((resolve) => {
+			this.waiting = resolve;
+		});
+	} });
+};
+function renderPartText(part) {
+	switch (part.type) {
+		case "text":
+		case "rich-text": return part.text;
+		case "source": return [
+			part.title ?? "",
+			part.url ?? "",
+			part.snippet ?? ""
+		].filter(Boolean).join("\n");
+		case "card": return (typeof part.payload.title === "string" ? part.payload.title.trim() : "") || JSON.stringify(part.payload);
+		case "action": return part.label.trim();
+		case "step-start": return part.title?.trim() ?? "";
+		default: return "";
+	}
+}
+var WeixinReplyChat = class {
+	mediaPartReader = new WeixinMediaPartReader();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	startTyping = async (target) => {
+		const account = this.deps.resolveAccount(target);
+		const contextToken = this.deps.resolveContextToken(target, account.accountId);
+		if (!contextToken) return;
+		await this.deps.typingController.start({
+			accountId: account.accountId,
+			userId: target.conversationId,
+			contextToken,
+			baseUrl: account.baseUrl,
+			token: account.token
+		});
+	};
+	stopTyping = async (target) => {
+		const account = this.deps.resolveAccount(target);
+		await this.deps.typingController.stop({
+			accountId: account.accountId,
+			userId: target.conversationId
+		});
+	};
+	sendError = async (target, message) => {
+		if (message.trim()) await this.sendText(target, message);
+	};
+	sendPart = async (target, part) => {
+		if (part.type === "file") {
+			await this.sendFilePart(target, part);
+			return;
+		}
+		const text = renderPartText(part);
+		if (text.trim()) await this.sendText(target, text);
+	};
+	sendText = async (target, text) => {
+		const account = this.deps.resolveAccount(target);
+		await this.deps.sendText({
+			account,
+			conversationId: target.conversationId,
+			text,
+			contextToken: this.deps.resolveContextToken(target, account.accountId)
+		});
+	};
+	sendFilePart = async (target, part) => {
+		const media = await this.mediaPartReader.read(target, part);
+		const account = this.deps.resolveAccount(target);
+		const contextToken = this.deps.resolveContextToken(target, account.accountId);
+		if (media.isImage) {
+			await sendWeixinImageMessage({
+				baseUrl: account.baseUrl,
+				token: account.token,
+				toUserId: target.conversationId,
+				bytes: media.bytes,
+				width: media.imageWidth,
+				height: media.imageHeight,
+				contextToken
+			});
+			return;
+		}
+		await sendWeixinFileMessage({
+			baseUrl: account.baseUrl,
+			token: account.token,
+			toUserId: target.conversationId,
+			fileName: media.fileName,
+			bytes: media.bytes,
+			contextToken
+		});
+	};
+};
+//#endregion
+export { NcpEventQueue, TERMINAL_NCP_EVENT_TYPES, WeixinReplyChat };

package/dist/services/weixin-typing-controller.service.js

@@ -0,0 +1,109 @@
+//#region src/services/weixin-typing-controller.service.ts
+function buildTypingKey(accountId, userId) {
+	return `${accountId}:${userId}`;
+}
+var WeixinTypingController = class {
+	heartbeatMs;
+	ticketTtlMs;
+	ticketCache = /* @__PURE__ */ new Map();
+	activeSessions = /* @__PURE__ */ new Map();
+	sessionSequences = /* @__PURE__ */ new Map();
+	fetchTicket;
+	sendTyping;
+	constructor(options) {
+		const { fetchTicket, heartbeatMs, sendTyping, ticketTtlMs } = options;
+		this.heartbeatMs = Math.max(1e3, Math.trunc(heartbeatMs ?? 5e3));
+		this.ticketTtlMs = Math.max(this.heartbeatMs, Math.trunc(ticketTtlMs ?? 1440 * 60 * 1e3));
+		this.fetchTicket = fetchTicket;
+		this.sendTyping = sendTyping;
+	}
+	start = async (runtime) => {
+		const key = buildTypingKey(runtime.accountId, runtime.userId);
+		const sequence = this.bumpSequence(key);
+		await this.clearActiveSession({
+			accountId: runtime.accountId,
+			userId: runtime.userId,
+			sendCancel: false
+		});
+		const ticket = await this.getTicket(runtime);
+		if (!ticket || this.sessionSequences.get(key) !== sequence) return;
+		await this.sendTypingSafe({
+			...runtime,
+			ticket,
+			status: 1
+		});
+		if (this.sessionSequences.get(key) !== sequence) return;
+		const heartbeat = setInterval(() => {
+			const active = this.activeSessions.get(key);
+			if (!active || active.sequence !== sequence) return;
+			this.sendTypingSafe({
+				...active.runtime,
+				ticket: active.ticket,
+				status: 1
+			});
+		}, this.heartbeatMs);
+		this.activeSessions.set(key, {
+			heartbeat,
+			ticket,
+			runtime,
+			sequence
+		});
+	};
+	stop = async (params) => {
+		const key = buildTypingKey(params.accountId, params.userId);
+		this.bumpSequence(key);
+		await this.clearActiveSession(params);
+	};
+	stopAll = async () => {
+		const sessions = Array.from(this.activeSessions.values());
+		this.activeSessions.clear();
+		for (const session of sessions) {
+			this.bumpSequence(buildTypingKey(session.runtime.accountId, session.runtime.userId));
+			clearInterval(session.heartbeat);
+		}
+		await Promise.allSettled(sessions.map(async (session) => {
+			await this.sendTypingSafe({
+				...session.runtime,
+				ticket: session.ticket,
+				status: 2
+			});
+		}));
+	};
+	bumpSequence = (key) => {
+		const next = (this.sessionSequences.get(key) ?? 0) + 1;
+		this.sessionSequences.set(key, next);
+		return next;
+	};
+	clearActiveSession = async (params) => {
+		const key = buildTypingKey(params.accountId, params.userId);
+		const active = this.activeSessions.get(key);
+		if (!active) return;
+		clearInterval(active.heartbeat);
+		this.activeSessions.delete(key);
+		if (params.sendCancel === false) return;
+		await this.sendTypingSafe({
+			...active.runtime,
+			ticket: active.ticket,
+			status: 2
+		});
+	};
+	getTicket = async (runtime) => {
+		const key = buildTypingKey(runtime.accountId, runtime.userId);
+		const cached = this.ticketCache.get(key);
+		if (cached && cached.expiresAtMs > Date.now()) return cached.ticket;
+		const ticket = (await this.fetchTicket(runtime))?.trim();
+		if (!ticket) return;
+		this.ticketCache.set(key, {
+			ticket,
+			expiresAtMs: Date.now() + this.ticketTtlMs
+		});
+		return ticket;
+	};
+	sendTypingSafe = async (params) => {
+		try {
+			await this.sendTyping(params);
+		} catch {}
+	};
+};
+//#endregion
+export { WeixinTypingController };

package/dist/stores/weixin-account.store.d.ts

@@ -0,0 +1,19 @@
+//#region src/stores/weixin-account.store.d.ts
+type StoredWeixinAccount = {
+  accountId: string;
+  token: string;
+  baseUrl?: string;
+  userId?: string;
+  savedAt?: string;
+};
+type WeixinAccountStore = {
+  listAccountIds: () => string[];
+  loadAccount: (accountId: string) => StoredWeixinAccount | null;
+  saveAccount: (account: StoredWeixinAccount) => void;
+  deleteAccount: (accountId: string) => void;
+  loadCursor: (accountId: string) => string | undefined;
+  saveCursor: (accountId: string, cursor: string | undefined) => void;
+  deleteCursor: (accountId: string) => void;
+};
+//#endregion
+export { WeixinAccountStore };

package/dist/stores/weixin-account.store.js

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+//#region src/stores/weixin-account.store.ts
+function resolveNextclawHome() {
+	const override = process.env.NEXTCLAW_HOME?.trim();
+	return resolve(override || join(homedir(), ".nextclaw"));
+}
+function resolveWeixinDataDir() {
+	return join(resolveNextclawHome(), "channels", "weixin");
+}
+function resolveAccountsDir() {
+	return join(resolveWeixinDataDir(), "accounts");
+}
+function resolveCursorsDir() {
+	return join(resolveWeixinDataDir(), "cursors");
+}
+function toFileName(accountId) {
+	return `${encodeURIComponent(accountId)}.json`;
+}
+function readJsonFile(filePath) {
+	if (!existsSync(filePath)) return null;
+	try {
+		return JSON.parse(readFileSync(filePath, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+var FileWeixinAccountStore = class {
+	listAccountIds = () => {
+		if (!existsSync(resolveAccountsDir())) return [];
+		return readdirSync(resolveAccountsDir()).filter((entry) => entry.endsWith(".json")).map((entry) => decodeURIComponent(entry.slice(0, -5))).filter(Boolean);
+	};
+	loadAccount = (accountId) => {
+		return readJsonFile(join(resolveAccountsDir(), toFileName(accountId)));
+	};
+	saveAccount = (account) => {
+		mkdirSync(resolveAccountsDir(), { recursive: true });
+		writeFileSync(join(resolveAccountsDir(), toFileName(account.accountId)), JSON.stringify(account, null, 2));
+	};
+	deleteAccount = (accountId) => {
+		rmSync(join(resolveAccountsDir(), toFileName(accountId)), { force: true });
+	};
+	loadCursor = (accountId) => {
+		return readJsonFile(join(resolveCursorsDir(), toFileName(accountId)))?.cursor?.trim() || void 0;
+	};
+	saveCursor = (accountId, cursor) => {
+		mkdirSync(resolveCursorsDir(), { recursive: true });
+		writeFileSync(join(resolveCursorsDir(), toFileName(accountId)), JSON.stringify({ cursor: cursor ?? "" }, null, 2));
+	};
+	deleteCursor = (accountId) => {
+		rmSync(join(resolveCursorsDir(), toFileName(accountId)), { force: true });
+	};
+};
+//#endregion
+export { FileWeixinAccountStore };

package/dist/types/weixin-extension.types.d.ts

@@ -0,0 +1,43 @@
+import { NcpEndpointEvent } from "@nextclaw/ncp";
+import { ChannelSubmittedAttachment } from "@nextclaw/extension-sdk";
+
+//#region src/types/weixin-extension.types.d.ts
+type WeixinAccountConfig = {
+  enabled?: boolean;
+  baseUrl?: string;
+  allowFrom?: string[];
+};
+type WeixinChannelConfig = {
+  enabled?: boolean;
+  defaultAccountId?: string;
+  baseUrl?: string;
+  pollTimeoutMs?: number;
+  allowFrom?: string[];
+  accounts?: Record<string, WeixinAccountConfig>;
+};
+type WeixinInboundMessage = {
+  conversationId: string;
+  senderId: string;
+  text: string;
+  attachments?: ChannelSubmittedAttachment[];
+  accountId?: string;
+  contextToken?: string;
+  raw?: unknown;
+};
+type WeixinRuntimeAccount = {
+  accountId: string;
+  token: string;
+  enabled: boolean;
+  baseUrl: string;
+  pollTimeoutMs: number;
+  allowFrom: string[];
+};
+type WeixinChannelAdapter = {
+  configure: (config: WeixinChannelConfig) => Promise<void>;
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+  onMessage: (handler: (message: WeixinInboundMessage) => void | Promise<void>) => () => void;
+  sendNcpEvent: (event: NcpEndpointEvent) => Promise<void>;
+};
+//#endregion
+export { WeixinAccountConfig, WeixinChannelAdapter, WeixinChannelConfig, WeixinInboundMessage, WeixinRuntimeAccount };

package/dist/utils/weixin-config.utils.d.ts

@@ -0,0 +1,69 @@
+//#region src/utils/weixin-config.utils.d.ts
+declare const WEIXIN_EXTENSION_ID = "nextclaw-channel-extension-weixin";
+declare const WEIXIN_CHANNEL_ID = "weixin";
+declare const DEFAULT_WEIXIN_BASE_URL = "https://ilinkai.weixin.qq.com";
+declare const WEIXIN_CHANNEL_CONFIG_SCHEMA: {
+  readonly type: "object";
+  readonly additionalProperties: false;
+  readonly properties: {
+    readonly enabled: {
+      readonly type: "boolean";
+    };
+    readonly defaultAccountId: {
+      readonly type: "string";
+    };
+    readonly baseUrl: {
+      readonly type: "string";
+    };
+    readonly pollTimeoutMs: {
+      readonly type: "number";
+    };
+    readonly allowFrom: {
+      readonly type: "array";
+      readonly items: {
+        readonly type: "string";
+      };
+    };
+    readonly accounts: {
+      readonly type: "object";
+      readonly additionalProperties: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+          readonly enabled: {
+            readonly type: "boolean";
+          };
+          readonly baseUrl: {
+            readonly type: "string";
+          };
+          readonly allowFrom: {
+            readonly type: "array";
+            readonly items: {
+              readonly type: "string";
+            };
+          };
+        };
+      };
+    };
+  };
+};
+declare const WEIXIN_CHANNEL_CONFIG_UI_HINTS: {
+  readonly enabled: {
+    readonly label: "Enabled";
+  };
+  readonly defaultAccountId: {
+    readonly label: "Default Account ID";
+  };
+  readonly baseUrl: {
+    readonly label: "API Base URL";
+  };
+  readonly pollTimeoutMs: {
+    readonly label: "Long Poll Timeout (ms)";
+    readonly advanced: true;
+  };
+  readonly allowFrom: {
+    readonly label: "Allow From";
+  };
+};
+//#endregion
+export { DEFAULT_WEIXIN_BASE_URL, WEIXIN_CHANNEL_CONFIG_SCHEMA, WEIXIN_CHANNEL_CONFIG_UI_HINTS, WEIXIN_CHANNEL_ID, WEIXIN_EXTENSION_ID };