@nextclaw/channel-extension-weixin 0.1.1

package/dist/utils/weixin-config.utils.js

@@ -0,0 +1,107 @@
+//#region src/utils/weixin-config.utils.ts
+const WEIXIN_EXTENSION_ID = "nextclaw-channel-extension-weixin";
+const WEIXIN_CHANNEL_ID = "weixin";
+const DEFAULT_WEIXIN_BASE_URL = "https://ilinkai.weixin.qq.com";
+function toRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function readString(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function readStringArray(value) {
+	if (!Array.isArray(value)) return;
+	const values = value.map((entry) => readString(entry)).filter((entry) => Boolean(entry));
+	return values.length > 0 ? values : void 0;
+}
+function normalizeAccountConfig(value) {
+	const record = toRecord(value);
+	if (!record) return;
+	return {
+		enabled: typeof record.enabled === "boolean" ? record.enabled : void 0,
+		baseUrl: readString(record.baseUrl),
+		allowFrom: readStringArray(record.allowFrom)
+	};
+}
+function normalizeWeixinChannelConfig(value) {
+	const record = toRecord(value);
+	if (!record) return {};
+	const accounts = {};
+	for (const [accountId, rawAccountConfig] of Object.entries(toRecord(record.accounts) ?? {})) {
+		const normalized = normalizeAccountConfig(rawAccountConfig);
+		if (normalized) accounts[accountId] = normalized;
+	}
+	return {
+		enabled: typeof record.enabled === "boolean" ? record.enabled : void 0,
+		defaultAccountId: readString(record.defaultAccountId),
+		baseUrl: readString(record.baseUrl),
+		pollTimeoutMs: typeof record.pollTimeoutMs === "number" && Number.isFinite(record.pollTimeoutMs) ? Math.max(1e3, Math.trunc(record.pollTimeoutMs)) : void 0,
+		allowFrom: readStringArray(record.allowFrom),
+		accounts: Object.keys(accounts).length > 0 ? accounts : void 0
+	};
+}
+function buildLoggedInWeixinChannelConfig(params) {
+	const { accountId, allowUserId, baseUrl, config, replaceAccountIds } = params;
+	const current = normalizeWeixinChannelConfig(config);
+	const replacementIds = new Set((replaceAccountIds ?? []).map((accountId) => readString(accountId)).filter((replacementAccountId) => Boolean(replacementAccountId) && replacementAccountId !== accountId));
+	const accounts = Object.fromEntries(Object.entries(current.accounts ?? {}).filter(([accountId]) => !replacementIds.has(accountId)));
+	const currentAccount = current.accounts?.[accountId] ?? {};
+	const allowFrom = new Set([...currentAccount.allowFrom ?? [], ...allowUserId ? [allowUserId] : []]);
+	return {
+		...current,
+		enabled: true,
+		defaultAccountId: accountId,
+		baseUrl: current.baseUrl ?? baseUrl,
+		accounts: {
+			...accounts,
+			[accountId]: {
+				...currentAccount,
+				enabled: true,
+				baseUrl,
+				allowFrom: allowFrom.size > 0 ? [...allowFrom] : void 0
+			}
+		}
+	};
+}
+const WEIXIN_CHANNEL_CONFIG_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		enabled: { type: "boolean" },
+		defaultAccountId: { type: "string" },
+		baseUrl: { type: "string" },
+		pollTimeoutMs: { type: "number" },
+		allowFrom: {
+			type: "array",
+			items: { type: "string" }
+		},
+		accounts: {
+			type: "object",
+			additionalProperties: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					enabled: { type: "boolean" },
+					baseUrl: { type: "string" },
+					allowFrom: {
+						type: "array",
+						items: { type: "string" }
+					}
+				}
+			}
+		}
+	}
+};
+const WEIXIN_CHANNEL_CONFIG_UI_HINTS = {
+	enabled: { label: "Enabled" },
+	defaultAccountId: { label: "Default Account ID" },
+	baseUrl: { label: "API Base URL" },
+	pollTimeoutMs: {
+		label: "Long Poll Timeout (ms)",
+		advanced: true
+	},
+	allowFrom: { label: "Allow From" }
+};
+//#endregion
+export { DEFAULT_WEIXIN_BASE_URL, WEIXIN_CHANNEL_CONFIG_SCHEMA, WEIXIN_CHANNEL_CONFIG_UI_HINTS, WEIXIN_CHANNEL_ID, WEIXIN_EXTENSION_ID, buildLoggedInWeixinChannelConfig, normalizeWeixinChannelConfig };

package/dist/utils/weixin-inbound-media.utils.js

@@ -0,0 +1,215 @@
+import { createDecipheriv, randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
+import { extname, resolve } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+//#region src/utils/weixin-inbound-media.utils.ts
+const WEIXIN_INBOUND_MEDIA_MAX_BYTES = 100 * 1024 * 1024;
+const FILE_EXTENSION_MIME_MAP = {
+	".bmp": "image/bmp",
+	".cjs": "text/javascript",
+	".css": "text/css",
+	".csv": "text/csv",
+	".gif": "image/gif",
+	".go": "text/plain",
+	".html": "text/html",
+	".java": "text/plain",
+	".js": "text/javascript",
+	".json": "application/json",
+	".jsx": "text/plain",
+	".md": "text/markdown",
+	".markdown": "text/markdown",
+	".mjs": "text/javascript",
+	".pdf": "application/pdf",
+	".php": "text/plain",
+	".png": "image/png",
+	".py": "text/plain",
+	".rb": "text/plain",
+	".rs": "text/plain",
+	".scss": "text/x-scss",
+	".sh": "text/x-shellscript",
+	".sql": "application/sql",
+	".svg": "image/svg+xml",
+	".swift": "text/plain",
+	".ts": "text/plain",
+	".tsx": "text/plain",
+	".txt": "text/plain",
+	".webp": "image/webp",
+	".xml": "application/xml",
+	".yaml": "application/yaml",
+	".yml": "application/yaml"
+};
+function detectMimeFromBuffer(buffer) {
+	if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	]))) return "image/png";
+	if (buffer.length >= 3 && buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) return "image/jpeg";
+	if (buffer.length >= 6 && ["GIF87a", "GIF89a"].includes(buffer.subarray(0, 6).toString("ascii"))) return "image/gif";
+	if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") return "image/webp";
+	if (buffer.length >= 4 && buffer.subarray(0, 4).toString("ascii") === "%PDF") return "application/pdf";
+}
+function detectMimeFromFileName(fileName) {
+	const extension = extname(fileName ?? "").toLowerCase();
+	if (extension === ".jpg" || extension === ".jpeg") return "image/jpeg";
+	return FILE_EXTENSION_MIME_MAP[extension];
+}
+function mimeToExtension(contentType, fileName) {
+	const fileExtension = extname(fileName ?? "").trim();
+	if (fileExtension) return fileExtension;
+	switch (contentType) {
+		case "image/png": return ".png";
+		case "image/jpeg": return ".jpg";
+		case "image/gif": return ".gif";
+		case "image/webp": return ".webp";
+		case "application/pdf": return ".pdf";
+		default: return ".bin";
+	}
+}
+function preferSpecificContentType(params) {
+	const { detectedContentType, fileName, reportedContentType } = params;
+	const normalizedReported = reportedContentType?.trim().toLowerCase();
+	if (normalizedReported && normalizedReported !== "application/octet-stream") return normalizedReported;
+	return detectedContentType ?? detectMimeFromFileName(fileName) ?? reportedContentType;
+}
+async function saveMediaBuffer(buffer, contentType, fileName) {
+	if (buffer.length > WEIXIN_INBOUND_MEDIA_MAX_BYTES) throw new Error(`media exceeds maxBytes (${buffer.length} > ${WEIXIN_INBOUND_MEDIA_MAX_BYTES})`);
+	const resolvedContentType = preferSpecificContentType({
+		reportedContentType: contentType,
+		detectedContentType: detectMimeFromBuffer(buffer),
+		fileName
+	});
+	const targetDir = resolve(tmpdir(), "nextclaw-media", "inbound");
+	await mkdir(targetDir, { recursive: true });
+	const targetPath = resolve(targetDir, `${randomUUID()}${mimeToExtension(resolvedContentType, fileName)}`);
+	await writeFile(targetPath, buffer);
+	return {
+		path: targetPath,
+		contentType: resolvedContentType
+	};
+}
+function parseEncodedAesKey(aesKeyBase64) {
+	const decoded = Buffer.from(aesKeyBase64, "base64");
+	if (decoded.length === 16) return decoded;
+	if (decoded.length === 32 && /^[0-9a-fA-F]{32}$/.test(decoded.toString("ascii"))) return Buffer.from(decoded.toString("ascii"), "hex");
+	throw new Error(`unsupported aes_key payload (${decoded.length} bytes after base64 decode)`);
+}
+function parseAesKey(media, imageItem) {
+	const imageHexKey = imageItem?.aeskey?.trim();
+	if (imageHexKey) return Buffer.from(imageHexKey, "hex");
+	const encoded = media?.aes_key?.trim();
+	if (!encoded) return;
+	return parseEncodedAesKey(encoded);
+}
+function decryptAesEcb(ciphertext, key) {
+	const decipher = createDecipheriv("aes-128-ecb", key, null);
+	return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+function buildFallbackDownloadUrl(baseUrl, encryptedQueryParam) {
+	return `${new URL(baseUrl).origin}/download?encrypted_query_param=${encodeURIComponent(encryptedQueryParam)}`;
+}
+function resolveMediaUrl(media, baseUrl) {
+	const fullUrl = media?.full_url?.trim();
+	if (fullUrl) return fullUrl;
+	const encryptedQueryParam = media?.encrypt_query_param?.trim();
+	if (!encryptedQueryParam) return;
+	return buildFallbackDownloadUrl(baseUrl, encryptedQueryParam);
+}
+async function fetchMediaBuffer(url) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`download failed: ${response.status} ${response.statusText}`);
+	return {
+		buffer: Buffer.from(await response.arrayBuffer()),
+		contentType: response.headers.get("content-type") ?? void 0
+	};
+}
+async function resolveImageAttachment(params) {
+	const imageItem = params.item.image_item;
+	const media = imageItem?.media;
+	const url = resolveMediaUrl(media, params.baseUrl);
+	if (!url) return null;
+	try {
+		const { buffer, contentType } = await fetchMediaBuffer(url);
+		const key = parseAesKey(media, imageItem);
+		const plaintext = key ? decryptAesEcb(buffer, key) : buffer;
+		const saved = await saveMediaBuffer(plaintext, contentType);
+		return {
+			path: saved.path,
+			url,
+			mimeType: saved.contentType ?? detectMimeFromBuffer(plaintext) ?? "image/*",
+			size: plaintext.length,
+			source: "weixin",
+			status: "ready"
+		};
+	} catch {
+		return {
+			url,
+			mimeType: "image/*",
+			source: "weixin",
+			status: "remote-only",
+			errorCode: "download_failed"
+		};
+	}
+}
+async function resolveFileAttachment(params) {
+	const fileItem = params.item.file_item;
+	const media = fileItem?.media;
+	const fileName = fileItem?.file_name?.trim();
+	const url = resolveMediaUrl(media, params.baseUrl);
+	const hintedMimeType = detectMimeFromFileName(fileName);
+	if (!url) return fileName ? {
+		name: fileName,
+		mimeType: hintedMimeType,
+		source: "weixin",
+		status: "remote-only",
+		errorCode: "invalid_payload"
+	} : null;
+	try {
+		const { buffer, contentType } = await fetchMediaBuffer(url);
+		const key = parseAesKey(media);
+		const plaintext = key ? decryptAesEcb(buffer, key) : buffer;
+		const saved = await saveMediaBuffer(plaintext, contentType ?? hintedMimeType, fileName);
+		return {
+			name: fileName,
+			path: saved.path,
+			url,
+			mimeType: saved.contentType ?? hintedMimeType ?? "application/octet-stream",
+			size: plaintext.length,
+			source: "weixin",
+			status: "ready"
+		};
+	} catch {
+		return {
+			name: fileName,
+			url,
+			mimeType: hintedMimeType,
+			source: "weixin",
+			status: "remote-only",
+			errorCode: "download_failed"
+		};
+	}
+}
+async function resolveAttachmentFromItem(params) {
+	if (params.item.type === 2) return resolveImageAttachment(params);
+	if (params.item.type === 4) return resolveFileAttachment(params);
+	return null;
+}
+async function resolveWeixinInboundAttachments(params) {
+	const items = Array.isArray(params.message.item_list) ? params.message.item_list : [];
+	const attachments = [];
+	for (const item of items) {
+		const attachment = await resolveAttachmentFromItem({
+			item,
+			baseUrl: params.baseUrl
+		});
+		if (attachment) attachments.push(attachment);
+	}
+	return attachments;
+}
+//#endregion
+export { resolveWeixinInboundAttachments };

package/dist/utils/weixin-media.utils.js

@@ -0,0 +1,168 @@
+import { WEIXIN_API_TIMEOUT_MS, buildWeixinBaseInfo, fetchWeixinJson, normalizeWeixinBaseUrl, sendWeixinMessageItem } from "../services/weixin-api.service.js";
+import { createCipheriv, createHash, randomBytes } from "node:crypto";
+//#region src/utils/weixin-media.utils.ts
+const WEIXIN_UPLOAD_TIMEOUT_MS = 6e4;
+function buildWeixinUploadUrl(params) {
+	return `${new URL(params.baseUrl).origin}/upload?${new URLSearchParams({
+		encrypted_query_param: params.uploadParam,
+		filekey: params.fileKey
+	}).toString()}`;
+}
+function computeEncryptedSize(size) {
+	const blockSize = 16;
+	const remainder = size % blockSize;
+	return size + (remainder === 0 ? blockSize : blockSize - remainder);
+}
+function encryptWeixinBytes(bytes, aesKey) {
+	const cipher = createCipheriv("aes-128-ecb", aesKey, null);
+	return Buffer.concat([cipher.update(Buffer.from(bytes)), cipher.final()]);
+}
+function encodeWeixinMediaAesKey(aesKeyHex) {
+	return Buffer.from(aesKeyHex, "utf8").toString("base64");
+}
+async function withUploadTimeout(params) {
+	const { handler, signal: parentSignal, timeoutMs } = params;
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), Math.max(1e3, timeoutMs));
+	const abort = () => controller.abort();
+	parentSignal?.addEventListener("abort", abort, { once: true });
+	try {
+		return await handler(controller.signal);
+	} finally {
+		clearTimeout(timeout);
+		parentSignal?.removeEventListener("abort", abort);
+	}
+}
+async function fetchWeixinUploadUrl(params) {
+	const { aesKeyHex, baseUrl, bytes, fileKey, mediaType, signal, toUserId, token } = params;
+	const rawFileMd5 = createHash("md5").update(Buffer.from(bytes)).digest("hex");
+	return await fetchWeixinJson({
+		url: new URL("ilink/bot/getuploadurl", normalizeWeixinBaseUrl(baseUrl)).toString(),
+		token,
+		timeoutMs: WEIXIN_API_TIMEOUT_MS,
+		signal,
+		body: {
+			filekey: fileKey,
+			media_type: mediaType,
+			to_user_id: toUserId,
+			rawsize: bytes.byteLength,
+			rawfilemd5: rawFileMd5,
+			filesize: computeEncryptedSize(bytes.byteLength),
+			no_need_thumb: true,
+			aeskey: aesKeyHex,
+			base_info: buildWeixinBaseInfo()
+		}
+	});
+}
+async function uploadWeixinMedia(params) {
+	const { aesKey, baseUrl, bytes, fileKey, signal, uploadFullUrl, uploadParam } = params;
+	const uploadUrl = uploadFullUrl?.trim() ? uploadFullUrl.trim() : uploadParam ? buildWeixinUploadUrl({
+		baseUrl,
+		uploadParam,
+		fileKey
+	}) : null;
+	if (!uploadUrl) throw new Error("weixin upload failed: upload url is missing");
+	const ciphertext = encryptWeixinBytes(bytes, aesKey);
+	const response = await withUploadTimeout({
+		timeoutMs: WEIXIN_UPLOAD_TIMEOUT_MS,
+		signal,
+		handler: async (signal) => fetch(uploadUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/octet-stream" },
+			body: new Uint8Array(ciphertext),
+			signal
+		})
+	});
+	if (!response.ok) {
+		const message = await response.text();
+		throw new Error(`weixin upload failed: ${response.status} ${message || response.statusText}`);
+	}
+	const downloadEncryptedQueryParam = response.headers.get("x-encrypted-param")?.trim();
+	if (!downloadEncryptedQueryParam) throw new Error("weixin upload failed: x-encrypted-param is missing");
+	return {
+		downloadEncryptedQueryParam,
+		aesKeyHex: aesKey.toString("hex"),
+		fileSize: bytes.byteLength,
+		fileSizeCiphertext: ciphertext.byteLength
+	};
+}
+async function sendUploadedWeixinMediaItem(params) {
+	const { baseUrl, bytes, contextToken, item, mediaType, signal, toUserId, token } = params;
+	const fileKey = randomBytes(16).toString("hex");
+	const aesKey = randomBytes(16);
+	const uploadUrl = await fetchWeixinUploadUrl({
+		baseUrl,
+		token,
+		toUserId,
+		fileKey,
+		mediaType,
+		bytes,
+		aesKeyHex: aesKey.toString("hex"),
+		signal
+	});
+	return await sendWeixinMessageItem({
+		baseUrl,
+		token,
+		toUserId,
+		contextToken,
+		signal,
+		item: item(await uploadWeixinMedia({
+			baseUrl,
+			uploadParam: uploadUrl.upload_param,
+			uploadFullUrl: uploadUrl.upload_full_url,
+			fileKey,
+			bytes,
+			aesKey,
+			signal
+		}))
+	});
+}
+async function sendWeixinFileMessage(params) {
+	const { baseUrl, bytes, contextToken, fileName, signal, toUserId, token } = params;
+	return await sendUploadedWeixinMediaItem({
+		baseUrl,
+		token,
+		toUserId,
+		bytes,
+		contextToken,
+		mediaType: 3,
+		signal,
+		item: (uploaded) => ({
+			type: 4,
+			file_item: {
+				file_name: fileName,
+				len: String(uploaded.fileSize),
+				media: {
+					encrypt_query_param: uploaded.downloadEncryptedQueryParam,
+					aes_key: encodeWeixinMediaAesKey(uploaded.aesKeyHex),
+					encrypt_type: 1
+				}
+			}
+		})
+	});
+}
+async function sendWeixinImageMessage(params) {
+	const { baseUrl, bytes, contextToken, signal, toUserId, token } = params;
+	return await sendUploadedWeixinMediaItem({
+		baseUrl,
+		token,
+		toUserId,
+		bytes,
+		contextToken,
+		mediaType: 1,
+		signal,
+		item: (uploaded) => ({
+			type: 2,
+			image_item: {
+				media: {
+					encrypt_query_param: uploaded.downloadEncryptedQueryParam,
+					aes_key: encodeWeixinMediaAesKey(uploaded.aesKeyHex),
+					encrypt_type: 1
+				},
+				mid_size: uploaded.fileSizeCiphertext
+			}
+		})
+	});
+}
+//#endregion
+export { sendWeixinFileMessage, sendWeixinImageMessage };

package/dist/utils/weixin-session-route.utils.js

@@ -0,0 +1,38 @@
+//#region src/utils/weixin-session-route.utils.ts
+const PEER_KINDS = new Set([
+	"direct",
+	"group",
+	"channel"
+]);
+function readPayload(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value.payload;
+}
+function readNestedMessageSessionId(payload) {
+	const message = payload.message;
+	if (!message || typeof message !== "object" || Array.isArray(message)) return;
+	const sessionId = message.sessionId;
+	return typeof sessionId === "string" && sessionId.trim() ? sessionId.trim() : void 0;
+}
+function readWeixinEventSessionId(event) {
+	const payload = readPayload(event);
+	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return;
+	const sessionId = payload.sessionId;
+	if (typeof sessionId === "string" && sessionId.trim()) return sessionId.trim();
+	return readNestedMessageSessionId(payload);
+}
+function resolveWeixinSessionRoute(event) {
+	const sessionId = readWeixinEventSessionId(event);
+	if (!sessionId) return null;
+	const parts = sessionId.split(":");
+	const normalizedParts = parts.map((part) => part.toLowerCase());
+	if (normalizedParts[0] !== "agent" || parts.length < 5) return null;
+	if (normalizedParts[2] === "weixin" && PEER_KINDS.has(normalizedParts[3] ?? "") && parts.length >= 5) return { conversationId: parts.slice(4).join(":") };
+	if (normalizedParts[2] === "weixin" && PEER_KINDS.has(normalizedParts[4] ?? "") && parts.length >= 6) return {
+		accountId: parts[3],
+		conversationId: parts.slice(5).join(":")
+	};
+	return null;
+}
+//#endregion
+export { readWeixinEventSessionId, resolveWeixinSessionRoute };

package/nextclaw.extension.json

@@ -0,0 +1,58 @@
+{
+  "id": "nextclaw-channel-extension-weixin",
+  "name": "NextClaw Weixin Channel Extension",
+  "version": "0.1.0",
+  "server": {
+    "type": "stdio",
+    "command": "node",
+    "args": ["dist/main.js"]
+  },
+  "contributes": {
+    "channels": [
+      {
+        "id": "weixin",
+        "name": "Weixin",
+        "description": "Weixin QR login + getupdates long-poll channel",
+        "auth": {
+          "type": "request-response"
+        },
+        "configUiHints": {
+          "enabled": { "label": "Enabled" },
+          "defaultAccountId": { "label": "Default Account ID" },
+          "baseUrl": { "label": "API Base URL" },
+          "pollTimeoutMs": { "label": "Long Poll Timeout (ms)", "advanced": true },
+          "allowFrom": { "label": "Allow From" }
+        },
+        "configSchema": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": { "type": "boolean" },
+            "defaultAccountId": { "type": "string" },
+            "baseUrl": { "type": "string" },
+            "pollTimeoutMs": { "type": "number" },
+            "allowFrom": {
+              "type": "array",
+              "items": { "type": "string" }
+            },
+            "accounts": {
+              "type": "object",
+              "additionalProperties": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "enabled": { "type": "boolean" },
+                  "baseUrl": { "type": "string" },
+                  "allowFrom": {
+                    "type": "array",
+                    "items": { "type": "string" }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@nextclaw/channel-extension-weixin",
+  "version": "0.1.1",
+  "private": false,
+  "description": "NextClaw Weixin channel extension process.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "nextclaw.extension.json",
+    "README.md"
+  ],
+  "dependencies": {
+    "@nextclaw/extension-sdk": "0.1.1",
+    "@nextclaw/ncp-toolkit": "0.5.12",
+    "@nextclaw/ncp": "0.5.7"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.6",
+    "typescript": "^5.6.3",
+    "vitest": "^4.1.2"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts src/main.ts --dts --clean --target es2022 --no-fixedExtension --unbundle",
+    "lint": "eslint src --max-warnings=0",
+    "test": "vitest run",
+    "tsc": "tsc -p tsconfig.json"
+  }
+}