@openclaw/qqbot 2026.5.7 → 2026.5.9-beta.1

package/dist/{sender-p-B14eLG.js → sender-CgdXGY2H.js}

@@ -1,9 +1,12 @@
-import { c as getPlatformAdapter, i as normalizeOptionalString, n as normalizeLowercaseStringOrEmpty, s as sanitizeFileName } from "./string-normalize-Ci6NM5DE.js";
+import { c as getPlatformAdapter, i as normalizeOptionalString, s as sanitizeFileName } from "./string-normalize-Ci6NM5DE.js";
 import * as fs$1 from "node:fs";
 import os from "node:os";
 import * as crypto$1 from "node:crypto";
 import crypto from "node:crypto";
+import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
+import { FsSafeError, openLocalFileSafely, readRegularFile, statRegularFileSync } from "openclaw/plugin-sdk/security-runtime";
 import * as path$1 from "node:path";
+import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
 //#region extensions/qqbot/src/engine/types.ts
 /**
 * Core API layer public types.
@@ -259,19 +262,20 @@ const QQBOT_MEDIA_SSRF_POLICY = {
 /** Validate that a file is within the allowed upload size. */
 function checkFileSize(filePath, maxSize = MAX_UPLOAD_SIZE) {
 	try {
-		const stat = fs$1.statSync(filePath);
-		if (stat.size > maxSize) {
-			const sizeMB = (stat.size / (1024 * 1024)).toFixed(1);
+		const result = statRegularFileSync(filePath);
+		if (result.missing) throw Object.assign(/* @__PURE__ */ new Error(`File not found: ${filePath}`), { code: "ENOENT" });
+		if (result.stat.size > maxSize) {
+			const sizeMB = (result.stat.size / (1024 * 1024)).toFixed(1);
 			const limitMB = (maxSize / (1024 * 1024)).toFixed(0);
 			return {
 				ok: false,
-				size: stat.size,
+				size: result.stat.size,
 				error: `File is too large (${sizeMB}MB); QQ Bot API limit is ${limitMB}MB`
 			};
 		}
 		return {
 			ok: true,
-			size: stat.size
+			size: result.stat.size
 		};
 	} catch (err) {
 		return {
@@ -283,15 +287,18 @@ function checkFileSize(filePath, maxSize = MAX_UPLOAD_SIZE) {
 }
 /** Read file contents asynchronously. */
 async function readFileAsync(filePath) {
-	return fs$1.promises.readFile(filePath);
+	return (await readRegularFile({ filePath })).buffer;
 }
 /** Check file readability asynchronously. */
 async function fileExistsAsync(filePath) {
+	const opened = await openLocalFileSafely({ filePath }).catch(() => null);
+	if (!opened) return false;
 	try {
-		await fs$1.promises.access(filePath, fs$1.constants.R_OK);
 		return true;
 	} catch {
 		return false;
+	} finally {
+		await opened.handle.close().catch(() => void 0);
 	}
 }
 /** Format a byte count into a human-readable size string. */
@@ -302,31 +309,8 @@ function formatFileSize(bytes) {
 }
 /** Infer a MIME type from the file extension. */
 function getMimeType(filePath) {
-	return MIME_TYPES[normalizeLowercaseStringOrEmpty(path$1.extname(filePath))] ?? "application/octet-stream";
-}
-/** Canonical ext → MIME table. Single source of truth. */
-const MIME_TYPES = {
-	".jpg": "image/jpeg",
-	".jpeg": "image/jpeg",
-	".png": "image/png",
-	".gif": "image/gif",
-	".webp": "image/webp",
-	".bmp": "image/bmp",
-	".mp4": "video/mp4",
-	".mov": "video/quicktime",
-	".avi": "video/x-msvideo",
-	".mkv": "video/x-matroska",
-	".webm": "video/webm",
-	".pdf": "application/pdf",
-	".doc": "application/msword",
-	".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-	".xls": "application/vnd.ms-excel",
-	".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-	".zip": "application/zip",
-	".tar": "application/x-tar",
-	".gz": "application/gzip",
-	".txt": "text/plain"
-};
+	return mimeTypeFromFilePath(filePath) ?? "application/octet-stream";
+}
 /** Extensions accepted as image uploads by the QQ Bot media pipeline. */
 const IMAGE_EXTENSIONS = new Set([
 	".jpg",
@@ -345,9 +329,10 @@ const IMAGE_EXTENSIONS = new Set([
 * `data:image/...;base64,` URL).
 */
 function getImageMimeType(filePath) {
-	const ext = normalizeLowercaseStringOrEmpty(path$1.extname(filePath));
+	const ext = path$1.extname(filePath).toLowerCase();
 	if (!IMAGE_EXTENSIONS.has(ext)) return null;
-	return MIME_TYPES[ext] ?? null;
+	const mime = mimeTypeFromFilePath(filePath);
+	return mime?.startsWith("image/") ? mime : null;
 }
 /** Download a remote file into a local directory. */
 async function downloadFile(url, destDir, originalFilename) {
@@ -381,6 +366,117 @@ async function downloadFile(url, destDir, originalFilename) {
 	}
 }
 //#endregion
+//#region extensions/qqbot/src/engine/messaging/media-source.ts
+const DATA_URL_RE = /^data:([^;,]+);base64,(.+)$/i;
+/**
+* Parse a `data:<mime>;base64,<payload>` URL.
+*
+* Returns `null` when the string is not a data URL or does not declare
+* base64 encoding. Non-base64 data URLs are intentionally rejected because
+* the QQ upload API ingests raw base64, not arbitrary URL-encoded payloads.
+*/
+function tryParseDataUrl(value) {
+	if (!value.startsWith("data:")) return null;
+	const m = value.match(DATA_URL_RE);
+	if (!m) return null;
+	return {
+		mime: m[1],
+		data: m[2]
+	};
+}
+/**
+* Open a local file for upload with defense-in-depth:
+*
+* 1. `O_NOFOLLOW` refuses to traverse symlinks (prevents post-whitelist
+*    symlink swaps / TOCTOU attacks).
+* 2. `fstat` on the opened descriptor — NOT `fs.stat` on the path —
+*    so the size check applies to the exact byte stream we will read.
+* 3. Rejects non-regular files (sockets / devices / directories).
+* 4. Enforces a caller-specified `maxSize` (default {@link MAX_UPLOAD_SIZE})
+*    at open time, so oversized files fail fast without allocating a
+*    full buffer. Chunked upload callers should pass a larger ceiling
+*    (e.g. `CHUNKED_UPLOAD_MAX_SIZE` from `utils/file-utils.js`).
+*
+* The caller receives the open handle plus validated size and is expected
+* to either {@link OpenedLocalFile.handle.readFile} (one-shot path) or
+* stream via `fs.createReadStream` (chunked path).
+*/
+async function openLocalFile(filePath, opts = {}) {
+	const maxSize = opts.maxSize ?? 20971520;
+	const opened = await openLocalFileSafely({ filePath }).catch((err) => {
+		if (err instanceof FsSafeError && err.code === "not-file") throw new Error("Path is not a regular file", { cause: err });
+		throw err;
+	});
+	try {
+		if (opened.stat.size > maxSize) throw new Error(`File is too large (${formatFileSize(opened.stat.size)}); QQ Bot API limit is ${formatFileSize(maxSize)}`);
+		return {
+			handle: opened.handle,
+			size: opened.stat.size,
+			close: () => opened.handle.close()
+		};
+	} catch (err) {
+		await opened.handle.close().catch(() => void 0);
+		throw err;
+	}
+}
+/**
+* Normalize a {@link RawMediaSource} into a {@link MediaSource}.
+*
+* - Strings passed via `{ url }` that start with `data:` are auto-resolved
+*   to a `base64` branch (this is the unified `data:` URL support that was
+*   previously only implemented in `sendImage`).
+* - `localPath` branches open the file with {@link openLocalFile} and carry
+*   that descriptor to the uploader, so later reads use the exact file that
+*   passed regular-file / O_NOFOLLOW / size validation.
+* - `buffer` branches enforce the same ceiling inline.
+*
+* `maxSize` defaults to {@link MAX_UPLOAD_SIZE} (20MB, one-shot upload limit).
+* Callers that dispatch to the chunked uploader should pass a larger ceiling
+* (e.g. `CHUNKED_UPLOAD_MAX_SIZE`, or a value derived from
+* `getMaxUploadSize(fileType)`).
+*
+* NOTE: Root-whitelist validation (i.e. "this path must live under the
+* allowed QQ Bot media directory") is a caller concern. This function
+* assumes the path has already passed such checks.
+*/
+async function normalizeSource(raw, opts = {}) {
+	const maxSize = opts.maxSize ?? 20971520;
+	if ("url" in raw) {
+		const parsed = tryParseDataUrl(raw.url);
+		if (parsed) return {
+			kind: "base64",
+			data: parsed.data,
+			mime: parsed.mime
+		};
+		return {
+			kind: "url",
+			url: raw.url
+		};
+	}
+	if ("base64" in raw) return {
+		kind: "base64",
+		data: raw.base64,
+		mime: raw.mime
+	};
+	if ("localPath" in raw) {
+		const opened = await openLocalFile(raw.localPath, { maxSize });
+		return {
+			kind: "localPath",
+			path: raw.localPath,
+			size: opened.size,
+			mime: getMimeType(raw.localPath),
+			opened
+		};
+	}
+	if (raw.buffer.length > maxSize) throw new Error(`Buffer is too large (${formatFileSize(raw.buffer.length)}); QQ Bot API limit is ${formatFileSize(maxSize)}`);
+	return {
+		kind: "buffer",
+		buffer: raw.buffer,
+		fileName: raw.fileName,
+		mime: raw.mime
+	};
+}
+//#endregion
 //#region extensions/qqbot/src/engine/api/retry.ts
 /**
 * Execute an async operation with configurable retry semantics.
@@ -650,60 +746,62 @@ var ChunkedMediaApi = class {
 	*/
 	async uploadChunked(opts) {
 		const prefix = opts.logPrefix ?? "[qqbot:chunked-upload]";
-		const input = resolveSource(opts.source, opts.fileName);
-		const displayName = input.fileName;
-		const fileSize = input.size;
-		const pathLabel = input.kind === "localPath" ? input.path : "<buffer>";
-		this.logger?.info?.(`${prefix} Start: file=${displayName} size=${formatFileSize(fileSize)} type=${opts.fileType}`);
-		const hashes = await computeHashes(input);
-		this.logger?.debug?.(`${prefix} hashes: md5=${hashes.md5} sha1=${hashes.sha1} md5_10m=${hashes.md5_10m}`);
-		if (this.cache) {
-			const cached = this.cache.get(hashes.md5, opts.scope, opts.targetId, opts.fileType);
-			if (cached) {
-				this.logger?.info?.(`${prefix} cache HIT (md5=${hashes.md5.slice(0, 8)}) — skipping chunked upload`);
-				return {
-					file_uuid: "",
-					file_info: cached,
-					ttl: 0
-				};
-			}
-		}
-		const fileNameForPrepare = opts.fileType === 4 ? this.sanitize(displayName) : displayName;
-		const prepareResp = await this.callUploadPrepare(opts, fileNameForPrepare, fileSize, hashes, pathLabel);
-		const { upload_id, parts } = prepareResp;
-		const block_size = prepareResp.block_size;
-		const maxConcurrent = Math.min(prepareResp.concurrency ? prepareResp.concurrency : DEFAULT_CONCURRENT_PARTS, MAX_CONCURRENT_PARTS);
-		const retryTimeoutMs = prepareResp.retry_timeout ? Math.min(prepareResp.retry_timeout * 1e3, MAX_PART_FINISH_RETRY_TIMEOUT_MS) : void 0;
-		this.logger?.info?.(`${prefix} prepared: upload_id=${upload_id} block=${formatFileSize(block_size)} parts=${parts.length} concurrency=${maxConcurrent}`);
-		let completedParts = 0;
-		let uploadedBytes = 0;
-		const uploadPart = async (part) => {
-			const partIndex = part.index;
-			const offset = (partIndex - 1) * block_size;
-			const length = Math.min(block_size, fileSize - offset);
-			const partBuffer = await readPart(input, offset, length);
-			const md5Hex = crypto$1.createHash("md5").update(partBuffer).digest("hex");
-			this.logger?.debug?.(`${prefix} part ${partIndex}/${parts.length}: ${formatFileSize(length)} offset=${offset} md5=${md5Hex}`);
-			await putToPresignedUrl(part.presigned_url, partBuffer, partIndex, parts.length, this.logger, prefix);
-			await this.callUploadPartFinish(opts, upload_id, partIndex, length, md5Hex, retryTimeoutMs);
-			completedParts++;
-			uploadedBytes += length;
-			this.logger?.info?.(`${prefix} part ${partIndex}/${parts.length} done (${completedParts}/${parts.length})`);
-			opts.onProgress?.({
-				completedParts,
-				totalParts: parts.length,
-				uploadedBytes,
-				totalBytes: fileSize
-			});
-		};
+		const input = await resolveSource(opts.source, opts.fileName);
 		try {
+			const displayName = input.fileName;
+			const fileSize = input.size;
+			const pathLabel = input.kind === "localPath" ? input.path : "<buffer>";
+			this.logger?.info?.(`${prefix} Start: file=${displayName} size=${formatFileSize(fileSize)} type=${opts.fileType}`);
+			const hashes = await computeHashes(input);
+			this.logger?.debug?.(`${prefix} hashes: md5=${hashes.md5} sha1=${hashes.sha1} md5_10m=${hashes.md5_10m}`);
+			if (this.cache) {
+				const cached = this.cache.get(hashes.md5, opts.scope, opts.targetId, opts.fileType);
+				if (cached) {
+					this.logger?.info?.(`${prefix} cache HIT (md5=${hashes.md5.slice(0, 8)}) — skipping chunked upload`);
+					return {
+						file_uuid: "",
+						file_info: cached,
+						ttl: 0
+					};
+				}
+			}
+			const fileNameForPrepare = opts.fileType === 4 ? this.sanitize(displayName) : displayName;
+			const prepareResp = await this.callUploadPrepare(opts, fileNameForPrepare, fileSize, hashes, pathLabel);
+			const { upload_id, parts } = prepareResp;
+			const block_size = prepareResp.block_size;
+			const maxConcurrent = Math.min(prepareResp.concurrency ? prepareResp.concurrency : DEFAULT_CONCURRENT_PARTS, MAX_CONCURRENT_PARTS);
+			const retryTimeoutMs = prepareResp.retry_timeout ? Math.min(prepareResp.retry_timeout * 1e3, MAX_PART_FINISH_RETRY_TIMEOUT_MS) : void 0;
+			this.logger?.info?.(`${prefix} prepared: upload_id=${upload_id} block=${formatFileSize(block_size)} parts=${parts.length} concurrency=${maxConcurrent}`);
+			let completedParts = 0;
+			let uploadedBytes = 0;
+			const uploadPart = async (part) => {
+				const partIndex = part.index;
+				const offset = (partIndex - 1) * block_size;
+				const length = Math.min(block_size, fileSize - offset);
+				const partBuffer = await readPart(input, offset, length);
+				const md5Hex = crypto$1.createHash("md5").update(partBuffer).digest("hex");
+				this.logger?.debug?.(`${prefix} part ${partIndex}/${parts.length}: ${formatFileSize(length)} offset=${offset} md5=${md5Hex}`);
+				await putToPresignedUrl(part.presigned_url, partBuffer, partIndex, parts.length, this.logger, prefix);
+				await this.callUploadPartFinish(opts, upload_id, partIndex, length, md5Hex, retryTimeoutMs);
+				completedParts++;
+				uploadedBytes += length;
+				this.logger?.info?.(`${prefix} part ${partIndex}/${parts.length} done (${completedParts}/${parts.length})`);
+				opts.onProgress?.({
+					completedParts,
+					totalParts: parts.length,
+					uploadedBytes,
+					totalBytes: fileSize
+				});
+			};
 			await runWithConcurrency(parts.map((part) => () => uploadPart(part)), maxConcurrent);
-		} finally {}
-		this.logger?.info?.(`${prefix} all parts uploaded, completing...`);
-		const result = await this.callCompleteUpload(opts, upload_id);
-		this.logger?.info?.(`${prefix} completed: file_uuid=${result.file_uuid} ttl=${result.ttl}s`);
-		if (this.cache && result.file_info && result.ttl > 0) this.cache.set(hashes.md5, opts.scope, opts.targetId, opts.fileType, result.file_info, result.file_uuid, result.ttl);
-		return result;
+			this.logger?.info?.(`${prefix} all parts uploaded, completing...`);
+			const result = await this.callCompleteUpload(opts, upload_id);
+			this.logger?.info?.(`${prefix} completed: file_uuid=${result.file_uuid} ttl=${result.ttl}s`);
+			if (this.cache && result.file_info && result.ttl > 0) this.cache.set(hashes.md5, opts.scope, opts.targetId, opts.fileType, result.file_info, result.file_uuid, result.ttl);
+			return result;
+		} finally {
+			if (input.kind === "localPath" && input.closeWhenDone) await input.opened.close().catch(() => void 0);
+		}
 	}
 	async callUploadPrepare(opts, fileName, fileSize, hashes, pathLabel) {
 		const token = await this.tokenManager.getAccessToken(opts.creds.appId, opts.creds.clientSecret);
@@ -743,14 +841,17 @@ var ChunkedMediaApi = class {
 		}, COMPLETE_UPLOAD_RETRY_POLICY, void 0, this.logger);
 	}
 };
-function resolveSource(source, fileNameOverride) {
+async function resolveSource(source, fileNameOverride) {
 	if (source.kind === "localPath") {
 		const inferredName = source.path.split(/[/\\]/).pop() || "file";
+		const opened = source.opened ?? await openLocalFile(source.path, { maxSize: Number.MAX_SAFE_INTEGER });
 		return {
 			kind: "localPath",
 			path: source.path,
-			size: source.size,
-			fileName: fileNameOverride ?? inferredName
+			size: opened.size,
+			fileName: fileNameOverride ?? inferredName,
+			opened,
+			closeWhenDone: source.opened === void 0
 		};
 	}
 	if (source.kind === "buffer") return {
@@ -763,21 +864,16 @@ function resolveSource(source, fileNameOverride) {
 }
 async function readPart(input, offset, length) {
 	if (input.kind === "buffer") return input.buffer.subarray(offset, offset + length);
-	const handle = await fs$1.promises.open(input.path, "r");
-	try {
-		const buf = Buffer.alloc(length);
-		const { bytesRead } = await handle.read(buf, 0, length, offset);
-		return bytesRead < length ? buf.subarray(0, bytesRead) : buf;
-	} finally {
-		await handle.close();
-	}
+	const buf = Buffer.alloc(length);
+	const { bytesRead } = await input.opened.handle.read(buf, 0, length, offset);
+	return bytesRead < length ? buf.subarray(0, bytesRead) : buf;
 }
 /**
 * Stream the source once to compute md5 + sha1 + md5_10m.
 *
 * For buffer inputs the three hashes are computed in a single pass over
-* the existing memory. For localPath inputs a ReadStream drives the
-* hashers so memory use stays constant.
+* the existing memory. For localPath inputs the verified descriptor drives
+* the hashers so memory use stays constant.
 */
 async function computeHashes(input) {
 	if (input.kind === "buffer") {
@@ -794,7 +890,7 @@ async function computeHashes(input) {
 		const md5_10m = crypto$1.createHash("md5");
 		let consumed = 0;
 		const needsMd5_10m = input.size > MD5_10M_SIZE;
-		const stream = fs$1.createReadStream(input.path);
+		const stream = createReadStreamFromHandle(input.opened.handle);
 		stream.on("data", (chunk) => {
 			const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
 			md5.update(buf);
@@ -816,6 +912,12 @@ async function computeHashes(input) {
 		stream.on("error", reject);
 	});
 }
+function createReadStreamFromHandle(handle) {
+	return handle.createReadStream({
+		autoClose: false,
+		start: 0
+	});
+}
 /** Per-part retry budget for the COS PUT call (exponential backoff). */
 const PART_UPLOAD_MAX_RETRIES = 2;
 async function putToPresignedUrl(presignedUrl, data, partIndex, totalParts, logger, prefix) {
@@ -826,22 +928,30 @@ async function putToPresignedUrl(presignedUrl, data, partIndex, totalParts, logg
 		try {
 			const ab = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
 			const startTime = Date.now();
-			const response = await fetch(presignedUrl, {
-				method: "PUT",
-				body: new Blob([ab]),
-				headers: { "Content-Length": String(data.length) },
+			const { response, release } = await fetchWithSsrFGuard({
+				url: presignedUrl,
+				auditContext: "qqbot-media-part-upload",
+				init: {
+					method: "PUT",
+					body: new Blob([ab]),
+					headers: { "Content-Length": String(data.length) }
+				},
 				signal: controller.signal
 			});
-			const elapsed = Date.now() - startTime;
-			const requestId = response.headers.get("x-cos-request-id") ?? "-";
-			const etag = response.headers.get("ETag") ?? "-";
-			if (!response.ok) {
-				const body = await response.text().catch(() => "");
-				logger?.error?.(`${prefix} PUT part ${partIndex}/${totalParts}: HTTP ${response.status} ${response.statusText} (${elapsed}ms, requestId=${requestId}) body=${body.slice(0, 160)}`);
-				throw new Error(`COS PUT failed: ${response.status} ${response.statusText} - ${body.slice(0, 120)}`);
+			try {
+				const elapsed = Date.now() - startTime;
+				const requestId = response.headers.get("x-cos-request-id") ?? "-";
+				const etag = response.headers.get("ETag") ?? "-";
+				if (!response.ok) {
+					const body = await response.text().catch(() => "");
+					logger?.error?.(`${prefix} PUT part ${partIndex}/${totalParts}: HTTP ${response.status} ${response.statusText} (${elapsed}ms, requestId=${requestId}) body=${body.slice(0, 160)}`);
+					throw new Error(`COS PUT failed: ${response.status} ${response.statusText} - ${body.slice(0, 120)}`);
+				}
+				logger?.debug?.(`${prefix} PUT part ${partIndex}/${totalParts} OK (${elapsed}ms ETag=${etag} requestId=${requestId})`);
+				return;
+			} finally {
+				await release();
 			}
-			logger?.debug?.(`${prefix} PUT part ${partIndex}/${totalParts} OK (${elapsed}ms ETag=${etag} requestId=${requestId})`);
-			return;
 		} catch (err) {
 			lastError = err instanceof Error ? err : new Error(String(err));
 			if (lastError.name === "AbortError") lastError = /* @__PURE__ */ new Error(`Part ${partIndex}/${totalParts} upload timeout after ${PART_UPLOAD_TIMEOUT_MS}ms`);
@@ -1401,151 +1511,6 @@ function setCachedFileInfo(contentHash, scope, targetId, fileType, fileInfo, fil
 	debugLog(`[upload-cache] Cache SET: key=${key.slice(0, 40)}..., ttl=${effectiveTtl}s, uuid=${fileUuid}`);
 }
 //#endregion
-//#region extensions/qqbot/src/engine/messaging/media-source.ts
-/**
-* Unified media-source abstraction for the QQ Bot upload pipeline.
-*
-* All rich-media entry points (sender.ts#sendMedia, outbound.ts#send*,
-* reply-dispatcher.ts#handle*Payload) funnel through {@link normalizeSource}
-* before reaching the low-level {@link MediaApi}.
-*
-* ## Why four branches?
-*
-* - `url` — remote http(s) URL that the QQ server can fetch directly.
-* - `base64` — in-memory base64 string (typically from a `data:` URL).
-* - `localPath` — on-disk file; kept as a path so a future chunked-upload
-*   implementation can stream it via `fs.createReadStream` without the 4/3×
-*   base64 memory overhead.
-* - `buffer` — in-memory raw bytes (e.g. TTS output, downloaded url-fallback).
-*
-* ## Security baseline (localPath branch)
-*
-* `openLocalFile` is the single canonical implementation of "safely open a
-* local file for upload" across the plugin. It merges the previously
-* inconsistent strategies from `reply-dispatcher.ts` (O_NOFOLLOW + size check)
-* and `outbound.ts` (realpath + root containment). Callers are still
-* responsible for *root-whitelist* validation (via
-* `resolveQQBotPayloadLocalFilePath` / `resolveOutboundMediaPath`) before
-* passing the path in; this function enforces *file-level* safety only.
-*
-* Chunked upload is not implemented in this PR, but the contract here already
-* returns `size` metadata so `sendMediaInternal` can route by size without
-* reading the whole file first.
-*/
-const DATA_URL_RE = /^data:([^;,]+);base64,(.+)$/i;
-/**
-* Parse a `data:<mime>;base64,<payload>` URL.
-*
-* Returns `null` when the string is not a data URL or does not declare
-* base64 encoding. Non-base64 data URLs are intentionally rejected because
-* the QQ upload API ingests raw base64, not arbitrary URL-encoded payloads.
-*/
-function tryParseDataUrl(value) {
-	if (!value.startsWith("data:")) return null;
-	const m = value.match(DATA_URL_RE);
-	if (!m) return null;
-	return {
-		mime: m[1],
-		data: m[2]
-	};
-}
-/**
-* Open a local file for upload with defense-in-depth:
-*
-* 1. `O_NOFOLLOW` refuses to traverse symlinks (prevents post-whitelist
-*    symlink swaps / TOCTOU attacks).
-* 2. `fstat` on the opened descriptor — NOT `fs.stat` on the path —
-*    so the size check applies to the exact byte stream we will read.
-* 3. Rejects non-regular files (sockets / devices / directories).
-* 4. Enforces a caller-specified `maxSize` (default {@link MAX_UPLOAD_SIZE})
-*    at open time, so oversized files fail fast without allocating a
-*    full buffer. Chunked upload callers should pass a larger ceiling
-*    (e.g. `CHUNKED_UPLOAD_MAX_SIZE` from `utils/file-utils.js`).
-*
-* The caller receives the open handle plus validated size and is expected
-* to either {@link OpenedLocalFile.handle.readFile} (one-shot path) or
-* stream via `fs.createReadStream` (chunked path).
-*/
-async function openLocalFile(filePath, opts = {}) {
-	const maxSize = opts.maxSize ?? 20971520;
-	const openFlags = fs$1.constants.O_RDONLY | ("O_NOFOLLOW" in fs$1.constants ? fs$1.constants.O_NOFOLLOW : 0);
-	const handle = await fs$1.promises.open(filePath, openFlags);
-	try {
-		const stat = await handle.stat();
-		if (!stat.isFile()) throw new Error("Path is not a regular file");
-		if (stat.size > maxSize) throw new Error(`File is too large (${formatFileSize(stat.size)}); QQ Bot API limit is ${formatFileSize(maxSize)}`);
-		return {
-			handle,
-			size: stat.size,
-			close: () => handle.close()
-		};
-	} catch (err) {
-		await handle.close().catch(() => void 0);
-		throw err;
-	}
-}
-/**
-* Normalize a {@link RawMediaSource} into a {@link MediaSource}.
-*
-* - Strings passed via `{ url }` that start with `data:` are auto-resolved
-*   to a `base64` branch (this is the unified `data:` URL support that was
-*   previously only implemented in `sendImage`).
-* - `localPath` branches open the file with {@link openLocalFile} solely to
-*   validate size / regular-file / O_NOFOLLOW invariants. The handle is
-*   closed immediately — actual reading is deferred to the uploader so
-*   the chunked path can stream without double-reading.
-* - `buffer` branches enforce the same ceiling inline.
-*
-* `maxSize` defaults to {@link MAX_UPLOAD_SIZE} (20MB, one-shot upload limit).
-* Callers that dispatch to the chunked uploader should pass a larger ceiling
-* (e.g. `CHUNKED_UPLOAD_MAX_SIZE`, or a value derived from
-* `getMaxUploadSize(fileType)`).
-*
-* NOTE: Root-whitelist validation (i.e. "this path must live under the
-* allowed QQ Bot media directory") is a caller concern. This function
-* assumes the path has already passed such checks.
-*/
-async function normalizeSource(raw, opts = {}) {
-	const maxSize = opts.maxSize ?? 20971520;
-	if ("url" in raw) {
-		const parsed = tryParseDataUrl(raw.url);
-		if (parsed) return {
-			kind: "base64",
-			data: parsed.data,
-			mime: parsed.mime
-		};
-		return {
-			kind: "url",
-			url: raw.url
-		};
-	}
-	if ("base64" in raw) return {
-		kind: "base64",
-		data: raw.base64,
-		mime: raw.mime
-	};
-	if ("localPath" in raw) {
-		const opened = await openLocalFile(raw.localPath, { maxSize });
-		try {
-			return {
-				kind: "localPath",
-				path: raw.localPath,
-				size: opened.size,
-				mime: getMimeType(raw.localPath)
-			};
-		} finally {
-			await opened.close();
-		}
-	}
-	if (raw.buffer.length > maxSize) throw new Error(`Buffer is too large (${formatFileSize(raw.buffer.length)}); QQ Bot API limit is ${formatFileSize(maxSize)}`);
-	return {
-		kind: "buffer",
-		buffer: raw.buffer,
-		fileName: raw.fileName,
-		mime: raw.mime
-	};
-}
-//#endregion
 //#region extensions/qqbot/src/engine/messaging/sender.ts
 /**
 * Unified message sender — per-account resource management + business function layer.
@@ -1891,14 +1856,18 @@ async function sendMediaInternal(ctx, opts) {
 		clientSecret: opts.creds.clientSecret
 	};
 	const source = await normalizeSource(opts.source, { maxSize: Number.MAX_SAFE_INTEGER });
-	const uploadResult = await dispatchUpload(ctx, scope, opts.target.id, KIND_TO_FILE_TYPE[opts.kind], source, c, opts.fileName);
-	const msgContent = opts.kind === "image" || opts.kind === "video" ? opts.content : void 0;
-	const result = await ctx.mediaApi.sendMediaMessage(scope, opts.target.id, uploadResult.file_info, c, {
-		msgId: opts.msgId,
-		content: msgContent
-	});
-	notifyMediaHook(opts.creds.appId, result, buildOutboundMeta(opts, source));
-	return result;
+	try {
+		const uploadResult = await dispatchUpload(ctx, scope, opts.target.id, KIND_TO_FILE_TYPE[opts.kind], source, c, opts.fileName);
+		const msgContent = opts.kind === "image" || opts.kind === "video" ? opts.content : void 0;
+		const result = await ctx.mediaApi.sendMediaMessage(scope, opts.target.id, uploadResult.file_info, c, {
+			msgId: opts.msgId,
+			content: msgContent
+		});
+		notifyMediaHook(opts.creds.appId, result, buildOutboundMeta(opts, source));
+		return result;
+	} finally {
+		if (source.kind === "localPath") await source.opened?.close().catch(() => void 0);
+	}
 }
 /**
 * Upload a {@link MediaSource} via the one-shot or chunked path, chosen by
@@ -1931,6 +1900,10 @@ async function dispatchUpload(ctx, scope, targetId, fileType, source, creds, fil
 				creds,
 				fileName
 			});
+			if (source.opened) return ctx.mediaApi.uploadMedia(scope, targetId, fileType, creds, {
+				buffer: await source.opened.handle.readFile(),
+				fileName
+			});
 			return ctx.mediaApi.uploadMedia(scope, targetId, fileType, creds, {
 				localPath: source.path,
 				fileName
@@ -1984,4 +1957,4 @@ function supportsRichMedia(targetType) {
 	return targetType === "c2c" || targetType === "group";
 }
 //#endregion
-export { fileExistsAsync as A, StreamInputState as B, debugLog as C, UPLOAD_PREPARE_FALLBACK_CODE as D, getNextMsgSeq as E, readFileAsync as F, formatDuration as I, formatErrorMessage as L, getFileTypeName as M, getImageMimeType as N, checkFileSize as O, getMaxUploadSize as P, StreamContentType as R, debugError as S, UploadDailyLimitExceededError as T, setOpenClawVersion as _, createRawInputNotifyFn as a, withTokenRetry as b, getMessageApi as c, initSender as d, onMessageSent as f, sendText as g, sendMedia as h, clearTokenCache as i, formatFileSize as j, downloadFile as k, getPluginUserAgent as l, sendInputNotify as m, acknowledgeInteraction as n, getAccessToken as o, registerAccount as p, buildDeliveryTarget as r, getGatewayUrl as s, accountToCreds as t, initApiConfig as u, startBackgroundTokenRefresh as v, debugWarn as w, openLocalFile as x, stopBackgroundTokenRefresh as y, StreamInputMode as z };
+export { fileExistsAsync as A, StreamInputState as B, debugWarn as C, openLocalFile as D, UPLOAD_PREPARE_FALLBACK_CODE as E, readFileAsync as F, formatDuration as I, formatErrorMessage as L, getFileTypeName as M, getImageMimeType as N, checkFileSize as O, getMaxUploadSize as P, StreamContentType as R, debugLog as S, getNextMsgSeq as T, setOpenClawVersion as _, createRawInputNotifyFn as a, withTokenRetry as b, getMessageApi as c, initSender as d, onMessageSent as f, sendText as g, sendMedia as h, clearTokenCache as i, formatFileSize as j, downloadFile as k, getPluginUserAgent as l, sendInputNotify as m, acknowledgeInteraction as n, getAccessToken as o, registerAccount as p, buildDeliveryTarget as r, getGatewayUrl as s, accountToCreds as t, initApiConfig as u, startBackgroundTokenRefresh as v, UploadDailyLimitExceededError as w, debugError as x, stopBackgroundTokenRefresh as y, StreamInputMode as z };

package/dist/setup-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as qqbotSetupPlugin } from "./channel.setup-ByCRAe5H.js";
+import { t as qqbotSetupPlugin } from "./channel.setup-DS8qSqfn.js";
 export { qqbotSetupPlugin };

package/dist/{target-parser-Y0prnrXD.js → target-parser-DQ6J3Qe-.js}

@@ -1,5 +1,5 @@
 import { c as getPlatformAdapter } from "./string-normalize-Ci6NM5DE.js";
-import { C as debugLog, L as formatErrorMessage, w as debugWarn } from "./sender-p-B14eLG.js";
+import { C as debugWarn, L as formatErrorMessage, S as debugLog } from "./sender-CgdXGY2H.js";
 import * as fs$1 from "node:fs";
 import * as os$1 from "node:os";
 import * as path$1 from "node:path";