@openclaw/qqbot 2026.7.1-beta.1 → 2026.7.1-beta.4

package/dist/{outbound-Dfa2uOEp.js → outbound-BIrfvvFJ.js}

@@ -1,13 +1,17 @@
-import { A as getFileTypeName, D as downloadFile, E as checkFileSize, L as __exportAll, M as getMaxUploadSize, N as readFileAsync, O as fileExistsAsync, S as UploadDailyLimitExceededError, g as sendText$1, h as sendMedia$1, j as getImageMimeType, k as formatFileSize, t as accountToCreds, u as initApiConfig, w as UPLOAD_PREPARE_FALLBACK_CODE } from "./sender-BHWpE_yH.js";
+import { A as getFileTypeName, D as downloadFile, E as checkFileSize, L as __exportAll, M as getMaxUploadSize, N as readFileAsync, O as fileExistsAsync, S as UploadDailyLimitExceededError, g as sendText$1, h as sendMedia$1, j as getImageMimeType, k as formatFileSize, t as accountToCreds, u as initApiConfig, w as UPLOAD_PREPARE_FALLBACK_CODE } from "./sender-CjDuU-uz.js";
 import { c as getPlatformAdapter, i as normalizeOptionalString, n as normalizeLowercaseStringOrEmpty, s as sanitizeFileName } from "./string-normalize-R_0cKO7Q.js";
-import { a as formatErrorMessage, n as debugLog, r as debugWarn, t as debugError } from "./log-SDfMMBWe.js";
+import { a as formatErrorMessage, n as debugLog, r as debugWarn, t as debugError } from "./log-DEtcoDWe.js";
 import { r as parseTarget$1 } from "./target-parser-DagYRQkP.js";
-import * as fs$1 from "node:fs";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import * as fs$2 from "node:fs";
 import * as os$1 from "node:os";
+import { randomUUID } from "node:crypto";
 import { pathExistsSync, resolveLocalPathFromRootsSync } from "openclaw/plugin-sdk/security-runtime";
 import * as path$1 from "node:path";
 import path from "node:path";
-import { getFileExtension } from "openclaw/plugin-sdk/media-mime";
+import { extensionForMime, getFileExtension } from "openclaw/plugin-sdk/media-mime";
+import { mkdir, writeFile } from "node:fs/promises";
+import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
 import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/sandbox";
 //#region extensions/qqbot/src/engine/utils/platform.ts
 /**
@@ -32,10 +36,10 @@ import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/sandbox";
 function getHomeDir() {
 	try {
 		const home = os$1.homedir();
-		if (home && fs$1.existsSync(home)) return home;
+		if (home && fs$2.existsSync(home)) return home;
 	} catch {}
 	const envHome = process.env.HOME || process.env.USERPROFILE;
-	if (envHome && fs$1.existsSync(envHome)) return envHome;
+	if (envHome && fs$2.existsSync(envHome)) return envHome;
 	return getPlatformAdapter().getTempDir();
 }
 /**
@@ -76,7 +80,7 @@ function getQQBotDataPath(...subPaths) {
 /** Return a path under `~/.openclaw/qqbot`, creating it on demand. */
 function getQQBotDataDir(...subPaths) {
 	const dir = getQQBotDataPath(...subPaths);
-	if (!fs$1.existsSync(dir)) fs$1.mkdirSync(dir, { recursive: true });
+	if (!fs$2.existsSync(dir)) fs$2.mkdirSync(dir, { recursive: true });
 	return dir;
 }
 /**
@@ -94,7 +98,7 @@ function getQQBotMediaPath(...subPaths) {
 /** Return a path under `<openclaw-home>/.openclaw/media/qqbot`, creating it on demand. */
 function getQQBotMediaDir(...subPaths) {
 	const dir = getQQBotMediaPath(...subPaths);
-	if (!fs$1.existsSync(dir)) fs$1.mkdirSync(dir, { recursive: true });
+	if (!fs$2.existsSync(dir)) fs$2.mkdirSync(dir, { recursive: true });
 	return dir;
 }
 /**
@@ -124,7 +128,7 @@ async function checkSilkWasmAvailable() {
 	if (silkWasmAvailable !== null) return silkWasmAvailable;
 	try {
 		const { isSilk } = await import("silk-wasm");
-		isSilk(new Uint8Array(0));
+		isSilk(/* @__PURE__ */ new Uint8Array(0));
 		silkWasmAvailable = true;
 		debugLog("[platform] silk-wasm: available");
 	} catch (err) {
@@ -163,20 +167,20 @@ function isLocalPath(p) {
 	if (p.startsWith(".\\") || p.startsWith("..\\")) return true;
 	return false;
 }
-function isPathWithinRoot(candidate, root) {
+function isPathWithinRoot$1(candidate, root) {
 	const relative = path$1.relative(root, candidate);
 	return relative === "" || !relative.startsWith("..") && !path$1.isAbsolute(relative);
 }
 /** Remap legacy or hallucinated QQ Bot local media paths to real files when possible. */
 function resolveQQBotLocalMediaPath(p) {
 	const normalized = normalizePath$1(p);
-	if (!isLocalPath(normalized) || fs$1.existsSync(normalized)) return normalized;
+	if (!isLocalPath(normalized) || fs$2.existsSync(normalized)) return normalized;
 	const osHomeDir = getHomeDir();
 	const openclawHomeDir = resolveOpenClawHome();
 	const mediaRoot = getQQBotMediaPath();
 	const dataRoot = getQQBotDataPath();
 	const candidateRoots = [
-		...Array.from(new Set([path$1.join(osHomeDir, ".openclaw", "workspace", "qqbot"), path$1.join(openclawHomeDir, ".openclaw", "workspace", "qqbot")])).map((from) => ({
+		...Array.from(/* @__PURE__ */ new Set([path$1.join(osHomeDir, ".openclaw", "workspace", "qqbot"), path$1.join(openclawHomeDir, ".openclaw", "workspace", "qqbot")])).map((from) => ({
 			from,
 			to: mediaRoot
 		})),
@@ -190,10 +194,10 @@ function resolveQQBotLocalMediaPath(p) {
 		}
 	];
 	for (const { from, to } of candidateRoots) {
-		if (!isPathWithinRoot(normalized, from)) continue;
+		if (!isPathWithinRoot$1(normalized, from)) continue;
 		const relative = path$1.relative(from, normalized);
 		const candidate = path$1.join(to, relative);
-		if (fs$1.existsSync(candidate)) {
+		if (fs$2.existsSync(candidate)) {
 			debugWarn(`[platform] Remapped missing QQBot media path ${normalized} -> ${candidate}`);
 			return candidate;
 		}
@@ -208,12 +212,12 @@ function resolveQQBotPayloadLocalFilePath(p) {
 	const candidate = resolveQQBotLocalMediaPath(p);
 	if (!candidate.trim()) return null;
 	const resolvedCandidate = path$1.resolve(candidate);
-	if (!fs$1.existsSync(resolvedCandidate)) return null;
-	const canonicalCandidate = fs$1.realpathSync(resolvedCandidate);
+	if (!fs$2.existsSync(resolvedCandidate)) return null;
+	const canonicalCandidate = fs$2.realpathSync(resolvedCandidate);
 	const allowedRoots = [getOpenClawMediaDir(), getQQBotMediaPath()];
 	for (const root of allowedRoots) {
 		const resolvedRoot = path$1.resolve(root);
-		if (isPathWithinRoot(canonicalCandidate, fs$1.existsSync(resolvedRoot) ? fs$1.realpathSync(resolvedRoot) : resolvedRoot)) return canonicalCandidate;
+		if (isPathWithinRoot$1(canonicalCandidate, fs$2.existsSync(resolvedRoot) ? fs$2.realpathSync(resolvedRoot) : resolvedRoot)) return canonicalCandidate;
 	}
 	return null;
 }
@@ -406,6 +410,46 @@ function buildFileTooLargeResult(fileType, fileSize) {
 	};
 }
 //#endregion
+//#region extensions/qqbot/src/engine/messaging/outbound-media-path.ts
+function mergeMediaLocalRoots(...groups) {
+	const roots = groups.flatMap((group) => group ?? []).map((root) => root.trim()).filter(Boolean);
+	return roots.length > 0 ? Array.from(new Set(roots)) : void 0;
+}
+function resolveOutboundMediaLocalRoots(ctx) {
+	return mergeMediaLocalRoots(ctx.mediaAccess?.localRoots, ctx.mediaLocalRoots);
+}
+function isPathWithinRoot(candidatePath, rootPath) {
+	const resolvedRoot = path.resolve(rootPath);
+	if (resolvedRoot === path.parse(resolvedRoot).root) return false;
+	const relative = path.relative(resolvedRoot, path.resolve(candidatePath));
+	return relative === "" || relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function resolvePathInsideWorkspace(workspaceDir, pathWithinWorkspace) {
+	const mappedPath = path.resolve(workspaceDir, pathWithinWorkspace);
+	return isPathWithinRoot(mappedPath, workspaceDir) ? mappedPath : null;
+}
+function isVirtualWorkspacePath(normalizedPath) {
+	return normalizedPath === "/workspace" || normalizedPath.startsWith("/workspace/");
+}
+function resolveWorkspaceScopedLocalRoots(roots, workspaceDir) {
+	if (!roots?.length) return;
+	const scopedRoots = roots.map((root) => root.trim()).filter(Boolean).map((root) => workspaceDir && isVirtualWorkspacePath(root) ? resolveWorkspacePathCandidate(root, workspaceDir) : root).filter((root) => Boolean(root));
+	return scopedRoots.length > 0 ? Array.from(new Set(scopedRoots)) : void 0;
+}
+function resolveWorkspacePathCandidate(normalizedPath, workspaceDir) {
+	if (!workspaceDir) return isVirtualWorkspacePath(normalizedPath) ? null : normalizedPath;
+	if (normalizedPath === "/workspace") return workspaceDir;
+	if (normalizedPath.startsWith("/workspace/")) return resolvePathInsideWorkspace(workspaceDir, normalizedPath.slice(11));
+	if (path.isAbsolute(normalizedPath)) return normalizedPath;
+	return resolvePathInsideWorkspace(workspaceDir, normalizedPath);
+}
+function resolveWorkspacePathCandidates(normalizedPath, workspaceDir) {
+	const mappedPath = resolveWorkspacePathCandidate(normalizedPath, workspaceDir);
+	if (!mappedPath) return [];
+	if (mappedPath === normalizedPath) return [normalizedPath];
+	return path.isAbsolute(normalizedPath) && !isVirtualWorkspacePath(normalizedPath) ? [normalizedPath, mappedPath] : [mappedPath];
+}
+//#endregion
 //#region extensions/qqbot/src/engine/messaging/trusted-media-path.ts
 let cachedTrustedTmpRoot;
 function trustedOpenClawTmpRoot() {
@@ -462,11 +506,15 @@ function parseTarget(to) {
 /** Build a media target from a normal outbound context. */
 function buildMediaTarget(ctx) {
 	const target = parseTarget(ctx.to);
+	const mediaLocalRoots = resolveOutboundMediaLocalRoots(ctx);
 	return {
 		targetType: target.type,
 		targetId: target.id,
 		account: ctx.account,
-		replyToId: ctx.replyToId ?? void 0
+		replyToId: ctx.replyToId ?? void 0,
+		...mediaLocalRoots ? { mediaLocalRoots } : {},
+		...ctx.mediaAccess ? { mediaAccess: ctx.mediaAccess } : {},
+		...ctx.mediaReadFile ? { mediaReadFile: ctx.mediaReadFile } : {}
 	};
 }
 /** Return true when public URLs should be passed through directly. */
@@ -480,19 +528,28 @@ const qqBotMediaKindLabel = {
 	file: "File",
 	media: "Media"
 };
+function isHttpUrl(pathValue) {
+	return pathValue.startsWith("http://") || pathValue.startsWith("https://");
+}
+function isDataUrl(pathValue) {
+	return pathValue.startsWith("data:");
+}
 function isHttpOrDataSource(pathValue) {
-	return pathValue.startsWith("http://") || pathValue.startsWith("https://") || pathValue.startsWith("data:");
+	return isHttpUrl(pathValue) || isDataUrl(pathValue);
 }
-function resolveMissingPathWithinMediaRoot(normalizedPath) {
+function resolveMissingPathWithinRoots(normalizedPath, allowedRoots) {
 	const resolvedCandidate = path.resolve(normalizedPath);
 	if (pathExistsSync(resolvedCandidate)) return null;
 	return resolveLocalPathFromRootsSync({
 		filePath: resolvedCandidate,
-		roots: [getQQBotMediaDir()],
-		label: "QQ Bot media storage",
+		roots: allowedRoots,
+		label: "QQ Bot local roots",
 		allowMissing: true
 	})?.path ?? null;
 }
+function isPathWithinAnyRoot(candidatePath, allowedRoots) {
+	return allowedRoots?.some((root) => root.trim() && isPathWithinRoot(candidatePath, root)) ?? false;
+}
 function resolveExistingPathWithinRoots(normalizedPath, allowedRoots) {
 	return resolveLocalPathFromRootsSync({
 		filePath: normalizedPath,
@@ -500,30 +557,166 @@ function resolveExistingPathWithinRoots(normalizedPath, allowedRoots) {
 		label: "QQ Bot local roots"
 	})?.path ?? null;
 }
+function resolveOutboundMediaReadFile(ctx) {
+	return ctx.mediaAccess?.readFile ?? ctx.mediaReadFile;
+}
+function resolveHostReadMediaAccess(ctx) {
+	const mediaLocalRoots = resolveWorkspaceScopedLocalRoots(resolveOutboundMediaLocalRoots(ctx), ctx.mediaAccess?.workspaceDir);
+	if (!ctx.mediaAccess && !mediaLocalRoots) return;
+	const { localRoots: _localRoots, ...mediaAccessWithoutRoots } = ctx.mediaAccess ?? {};
+	return {
+		...mediaAccessWithoutRoots,
+		...mediaLocalRoots ? { localRoots: mediaLocalRoots } : {}
+	};
+}
+function mediaFileTypeForKind(mediaKind) {
+	switch (mediaKind) {
+		case "image": return 1;
+		case "voice": return 3;
+		case "video": return 2;
+		default: return 4;
+	}
+}
+function senderKindForLoadedMedia(mediaKind, loadedKind) {
+	if (mediaKind === "image") return loadedKind === "image" ? "image" : null;
+	if (mediaKind === "video") return loadedKind === "video" ? "video" : null;
+	if (mediaKind === "file") return "file";
+	if (loadedKind === "image") return "image";
+	if (loadedKind === "video") return "video";
+	return "file";
+}
+function resolveHostReadMediaPath(ctx, mediaPath) {
+	const normalizedPath = normalizePath$1(mediaPath);
+	if (path.isAbsolute(normalizedPath)) {
+		if (normalizedPath === "/workspace" || normalizedPath.startsWith("/workspace/")) return ctx.mediaAccess?.workspaceDir ? resolveWorkspacePathCandidate(normalizedPath, ctx.mediaAccess.workspaceDir) : null;
+		if (isPathWithinAnyRoot(normalizedPath, resolveOutboundMediaLocalRoots(ctx))) return normalizedPath;
+		return null;
+	}
+	if (!ctx.mediaAccess?.workspaceDir) return null;
+	return resolveWorkspacePathCandidate(normalizedPath, ctx.mediaAccess.workspaceDir);
+}
+async function stageLoadedHostReadVoice(mediaPath, loaded) {
+	const stagedDir = getQQBotMediaDir("host-read", "voice");
+	await mkdir(stagedDir, { recursive: true });
+	const rawFileName = sanitizeFileName(loaded.fileName || path.basename(mediaPath) || "voice");
+	const ext = path.extname(rawFileName);
+	const inferredExt = extensionForMime(loaded.contentType);
+	const baseName = sanitizeFileName(path.basename(rawFileName, ext)) || "voice";
+	const stagedPath = path.join(stagedDir, `${baseName}-${randomUUID()}${ext || inferredExt || ".bin"}`);
+	await writeFile(stagedPath, loaded.buffer);
+	return stagedPath;
+}
+async function stageHostReadVoice(ctx, mediaPath) {
+	const mediaReadFile = resolveOutboundMediaReadFile(ctx);
+	if (!mediaReadFile || isHttpOrDataSource(mediaPath)) return null;
+	const hostReadMediaPath = resolveHostReadMediaPath(ctx, mediaPath);
+	if (!hostReadMediaPath) return null;
+	const mediaAccess = resolveHostReadMediaAccess(ctx);
+	const loaded = await loadOutboundMediaFromUrl(hostReadMediaPath, {
+		maxBytes: getMaxUploadSize(3),
+		mediaAccess,
+		mediaReadFile,
+		workspaceDir: mediaAccess?.workspaceDir
+	});
+	if (loaded.kind !== "audio") throw new Error(`Unsupported voice media type: ${loaded.kind ?? "unknown"}`);
+	return await stageLoadedHostReadVoice(mediaPath, loaded);
+}
+async function trySendViaHostRead(ctx, mediaPath, mediaKind) {
+	const mediaReadFile = resolveOutboundMediaReadFile(ctx);
+	if (!mediaReadFile || isHttpOrDataSource(mediaPath)) return null;
+	const hostReadMediaPath = resolveHostReadMediaPath(ctx, mediaPath);
+	if (!hostReadMediaPath) return null;
+	const mediaAccess = resolveHostReadMediaAccess(ctx);
+	try {
+		const loaded = await loadOutboundMediaFromUrl(hostReadMediaPath, {
+			maxBytes: getMaxUploadSize(mediaFileTypeForKind(mediaKind)),
+			mediaAccess,
+			mediaReadFile,
+			workspaceDir: mediaAccess?.workspaceDir
+		});
+		const kind = senderKindForLoadedMedia(mediaKind, loaded.kind);
+		if (!kind) return {
+			channel: "qqbot",
+			error: `Unsupported ${mediaKind} media type: ${loaded.kind ?? "unknown"}`
+		};
+		if (loaded.buffer.length === 0) return {
+			channel: "qqbot",
+			error: `File is empty: ${hostReadMediaPath}`
+		};
+		if (mediaKind === "media" && loaded.kind === "audio") {
+			const directUploadFormats = ctx.account.config?.audioFormatPolicy?.uploadDirectFormats ?? ctx.account.config?.voiceDirectUploadFormats;
+			const transcodeEnabled = ctx.account.config?.audioFormatPolicy?.transcodeEnabled !== false;
+			return await sendVoiceFromLocal(ctx, await stageLoadedHostReadVoice(mediaPath, loaded), directUploadFormats, transcodeEnabled);
+		}
+		const creds = accountToCreds(ctx.account);
+		const target = {
+			type: ctx.targetType,
+			id: ctx.targetId
+		};
+		if (target.type !== "c2c" && target.type !== "group") return {
+			channel: "qqbot",
+			error: `${qqBotMediaKindLabel[mediaKind]} not supported in channel`
+		};
+		const r = await sendMedia$1({
+			target,
+			creds,
+			kind,
+			source: {
+				buffer: loaded.buffer,
+				...loaded.fileName ? { fileName: sanitizeFileName(loaded.fileName) } : {},
+				...loaded.contentType ? { mime: loaded.contentType } : {}
+			},
+			msgId: ctx.replyToId,
+			...kind === "file" && loaded.fileName ? { fileName: sanitizeFileName(loaded.fileName) } : {}
+		});
+		return {
+			channel: "qqbot",
+			messageId: r.id,
+			timestamp: r.timestamp
+		};
+	} catch (err) {
+		if (err instanceof UploadDailyLimitExceededError) return buildDailyLimitExceededResult(err.filePath === "<buffer>" ? new UploadDailyLimitExceededError(hostReadMediaPath, err.fileSize, err.message) : err);
+		return {
+			channel: "qqbot",
+			error: formatErrorMessage(err)
+		};
+	}
+}
+async function sendAutoDetectedMedia(ctx, mediaPath) {
+	const hostReadResult = await trySendViaHostRead(ctx, mediaPath, "media");
+	if (hostReadResult) return hostReadResult;
+	return await sendDocument(ctx, mediaPath);
+}
 function resolveOutboundMediaPath(rawPath, mediaKind, options = {}) {
 	const normalizedPath = normalizePath$1(rawPath);
 	if (isHttpOrDataSource(normalizedPath)) return {
 		ok: true,
 		mediaPath: normalizedPath
 	};
-	const allowedPath = resolveTrustedOutboundMediaPath(normalizedPath, { allowMissing: options.allowMissingLocalPath });
-	if (allowedPath) return {
-		ok: true,
-		mediaPath: allowedPath
-	};
-	if (options.extraLocalRoots && options.extraLocalRoots.length > 0) {
-		const extraAllowedPath = resolveExistingPathWithinRoots(normalizedPath, options.extraLocalRoots);
-		if (extraAllowedPath) return {
+	const candidatePaths = resolveWorkspacePathCandidates(normalizedPath, options.workspaceDir);
+	for (const candidatePath of candidatePaths) {
+		const allowedPath = resolveTrustedOutboundMediaPath(candidatePath, { allowMissing: options.allowMissingLocalPath });
+		if (allowedPath) return {
 			ok: true,
-			mediaPath: extraAllowedPath
+			mediaPath: allowedPath
 		};
+		if (options.extraLocalRoots && options.extraLocalRoots.length > 0) {
+			const extraAllowedPath = resolveExistingPathWithinRoots(candidatePath, options.extraLocalRoots);
+			if (extraAllowedPath) return {
+				ok: true,
+				mediaPath: extraAllowedPath
+			};
+		}
 	}
 	if (options.allowMissingLocalPath) {
-		const allowedMissingPath = resolveMissingPathWithinMediaRoot(normalizedPath);
-		if (allowedMissingPath) return {
-			ok: true,
-			mediaPath: allowedMissingPath
-		};
+		const missingRoots = mergeMediaLocalRoots([getQQBotMediaDir()], options.extraLocalRoots);
+		if (missingRoots) for (const candidatePath of candidatePaths) {
+			const allowedMissingPath = resolveMissingPathWithinRoots(candidatePath, missingRoots);
+			if (allowedMissingPath) return {
+				ok: true,
+				mediaPath: allowedMissingPath
+			};
+		}
 	}
 	debugWarn(`blocked local ${mediaKind} path outside QQ Bot media storage`);
 	return {
@@ -535,28 +728,33 @@ function resolveOutboundMediaPath(rawPath, mediaKind, options = {}) {
 * Send a photo from a local file, public URL, or Base64 data URL.
 */
 async function sendPhoto(ctx, imagePath) {
-	const resolvedMediaPath = resolveOutboundMediaPath(imagePath, "image");
+	const hostReadResult = await trySendViaHostRead(ctx, imagePath, "image");
+	if (hostReadResult) return hostReadResult;
+	const resolvedMediaPath = resolveOutboundMediaPath(imagePath, "image", {
+		extraLocalRoots: resolveOutboundMediaLocalRoots(ctx),
+		workspaceDir: ctx.mediaAccess?.workspaceDir
+	});
 	if (!resolvedMediaPath.ok) return {
 		channel: "qqbot",
 		error: resolvedMediaPath.error
 	};
 	const mediaPath = resolvedMediaPath.mediaPath;
 	const isLocal = isLocalPath(mediaPath);
-	const isHttp = mediaPath.startsWith("http://") || mediaPath.startsWith("https://");
-	const isData = mediaPath.startsWith("data:");
+	const isHttp = isHttpUrl(mediaPath);
+	const isData = isDataUrl(mediaPath);
 	if (isHttp && !shouldDirectUploadUrl(ctx.account)) {
 		debugLog(`sendPhoto: urlDirectUpload=false, downloading URL first...`);
 		const localFile = await downloadToFallbackDir(mediaPath, "sendPhoto");
 		if (localFile) return await sendPhotoFromLocal(ctx, localFile);
 		return {
 			channel: "qqbot",
-			error: `Failed to download image: ${mediaPath.slice(0, 80)}`
+			error: `Failed to download image: ${truncateUtf16Safe(mediaPath, 80)}`
 		};
 	}
 	if (isLocal) return await sendPhotoFromLocal(ctx, mediaPath);
 	if (!isHttp && !isData) return {
 		channel: "qqbot",
-		error: `Unsupported image source: ${mediaPath.slice(0, 50)}`
+		error: `Unsupported image source: ${truncateUtf16Safe(mediaPath, 50)}`
 	};
 	try {
 		const creds = accountToCreds(ctx.account);
@@ -663,13 +861,29 @@ async function sendPhotoFromLocal(ctx, mediaPath) {
 * URL handling respects `urlDirectUpload`, and local files are transcoded when needed.
 */
 async function sendVoice(ctx, voicePath, directUploadFormats, transcodeEnabled = true) {
-	const resolvedMediaPath = resolveOutboundMediaPath(voicePath, "voice", { allowMissingLocalPath: true });
+	let stagedHostReadVoice;
+	try {
+		stagedHostReadVoice = await stageHostReadVoice(ctx, voicePath);
+	} catch (err) {
+		return {
+			channel: "qqbot",
+			error: formatErrorMessage(err)
+		};
+	}
+	const resolvedMediaPath = stagedHostReadVoice ? {
+		ok: true,
+		mediaPath: stagedHostReadVoice
+	} : resolveOutboundMediaPath(voicePath, "voice", {
+		allowMissingLocalPath: true,
+		extraLocalRoots: resolveOutboundMediaLocalRoots(ctx),
+		workspaceDir: ctx.mediaAccess?.workspaceDir
+	});
 	if (!resolvedMediaPath.ok) return {
 		channel: "qqbot",
 		error: resolvedMediaPath.error
 	};
 	const mediaPath = resolvedMediaPath.mediaPath;
-	if (mediaPath.startsWith("http://") || mediaPath.startsWith("https://")) {
+	if (isHttpUrl(mediaPath)) {
 		if (shouldDirectUploadUrl(ctx.account)) try {
 			const creds = accountToCreds(ctx.account);
 			const target = {
@@ -703,7 +917,7 @@ async function sendVoice(ctx, voicePath, directUploadFormats, transcodeEnabled =
 		if (localFile) return await sendVoiceFromLocal(ctx, localFile, directUploadFormats, transcodeEnabled);
 		return {
 			channel: "qqbot",
-			error: `Failed to download audio: ${mediaPath.slice(0, 80)}`
+			error: `Failed to download audio: ${truncateUtf16Safe(mediaPath, 80)}`
 		};
 	}
 	return await sendVoiceFromLocal(ctx, mediaPath, directUploadFormats, transcodeEnabled);
@@ -716,7 +930,8 @@ async function sendVoiceFromLocal(ctx, mediaPath, directUploadFormats, transcode
 		error: "Voice generate failed"
 	};
 	if (fileSize > getMaxUploadSize(3)) return buildFileTooLargeResult(3, fileSize);
-	const safeMediaPath = resolveTrustedOutboundMediaPath(mediaPath);
+	const extraLocalRoots = resolveOutboundMediaLocalRoots(ctx);
+	const safeMediaPath = resolveTrustedOutboundMediaPath(mediaPath) ?? (extraLocalRoots ? resolveExistingPathWithinRoots(mediaPath, extraLocalRoots) : null);
 	if (!safeMediaPath) {
 		debugWarn(`sendVoice: blocked local voice path outside QQ Bot media storage`);
 		return {
@@ -779,20 +994,25 @@ async function sendVoiceFromLocal(ctx, mediaPath, directUploadFormats, transcode
 }
 /** Send video from either a public URL or a local file. */
 async function sendVideoMsg(ctx, videoPath) {
-	const resolvedMediaPath = resolveOutboundMediaPath(videoPath, "video");
+	const hostReadResult = await trySendViaHostRead(ctx, videoPath, "video");
+	if (hostReadResult) return hostReadResult;
+	const resolvedMediaPath = resolveOutboundMediaPath(videoPath, "video", {
+		extraLocalRoots: resolveOutboundMediaLocalRoots(ctx),
+		workspaceDir: ctx.mediaAccess?.workspaceDir
+	});
 	if (!resolvedMediaPath.ok) return {
 		channel: "qqbot",
 		error: resolvedMediaPath.error
 	};
 	const mediaPath = resolvedMediaPath.mediaPath;
-	const isHttp = mediaPath.startsWith("http://") || mediaPath.startsWith("https://");
+	const isHttp = isHttpUrl(mediaPath);
 	if (isHttp && !shouldDirectUploadUrl(ctx.account)) {
 		debugLog(`sendVideoMsg: urlDirectUpload=false, downloading URL first...`);
 		const localFile = await downloadToFallbackDir(mediaPath, "sendVideoMsg");
 		if (localFile) return await sendVideoFromLocal(ctx, localFile);
 		return {
 			channel: "qqbot",
-			error: `Failed to download video: ${mediaPath.slice(0, 80)}`
+			error: `Failed to download video: ${truncateUtf16Safe(mediaPath, 80)}`
 		};
 	}
 	try {
@@ -887,13 +1107,18 @@ async function sendVideoFromLocal(ctx, mediaPath) {
 }
 /** Send a file from a local path or public URL. */
 async function sendDocument(ctx, filePath, options = {}) {
-	const resolvedMediaPath = resolveOutboundMediaPath(filePath, "file", { extraLocalRoots: options.allowQQBotDataDownloads ? [getQQBotDataDir("downloads")] : void 0 });
+	const hostReadResult = await trySendViaHostRead(ctx, filePath, "file");
+	if (hostReadResult) return hostReadResult;
+	const resolvedMediaPath = resolveOutboundMediaPath(filePath, "file", {
+		extraLocalRoots: mergeMediaLocalRoots(options.allowQQBotDataDownloads ? [getQQBotDataDir("downloads")] : void 0, resolveOutboundMediaLocalRoots(ctx)),
+		workspaceDir: ctx.mediaAccess?.workspaceDir
+	});
 	if (!resolvedMediaPath.ok) return {
 		channel: "qqbot",
 		error: resolvedMediaPath.error
 	};
 	const mediaPath = resolvedMediaPath.mediaPath;
-	const isHttp = mediaPath.startsWith("http://") || mediaPath.startsWith("https://");
+	const isHttp = isHttpUrl(mediaPath);
 	const fileName = sanitizeFileName(path.basename(mediaPath));
 	if (isHttp && !shouldDirectUploadUrl(ctx.account)) {
 		debugLog(`sendDocument: urlDirectUpload=false, downloading URL first...`);
@@ -901,7 +1126,7 @@ async function sendDocument(ctx, filePath, options = {}) {
 		if (localFile) return await sendDocumentFromLocal(ctx, localFile);
 		return {
 			channel: "qqbot",
-			error: `Failed to download file: ${mediaPath.slice(0, 80)}`
+			error: `Failed to download file: ${truncateUtf16Safe(mediaPath, 80)}`
 		};
 	}
 	try {
@@ -918,7 +1143,7 @@ async function sendDocument(ctx, filePath, options = {}) {
 					kind: "file",
 					source: { url: mediaPath },
 					msgId: ctx.replyToId,
-					fileName
+					...fileName ? { fileName } : {}
 				});
 				return {
 					channel: "qqbot",
@@ -1006,7 +1231,7 @@ async function downloadToFallbackDir(httpUrl, caller) {
 	try {
 		const localFile = await downloadFile(httpUrl, getQQBotMediaDir("downloads", "url-fallback"));
 		if (!localFile) {
-			debugError(`${caller} fallback: download also failed for ${httpUrl.slice(0, 80)}`);
+			debugError(`${caller} fallback: download also failed for ${truncateUtf16Safe(httpUrl, 80)}`);
 			return null;
 		}
 		debugLog(`${caller} fallback: downloaded → ${localFile}`);
@@ -1171,7 +1396,8 @@ function parseQQBotPayload(text) {
 /** Encode a cron reminder payload into the stored cron-message format. */
 function encodePayloadForCron(payload) {
 	const jsonString = JSON.stringify(payload);
-	return `${CRON_PREFIX}${Buffer.from(jsonString, "utf-8").toString("base64")}`;
+	const base64 = Buffer.from(jsonString, "utf-8").toString("base64");
+	return `${CRON_PREFIX}${base64}`;
 }
 /** Decode a stored cron payload. */
 function decodeCronPayload(message) {
@@ -1288,7 +1514,7 @@ function decodeMediaPath(raw, log) {
 * These replace the inline `isImageFile` and `isVideoFile` helpers scattered
 * across `outbound.ts`. Centralizing them here keeps detection consistent.
 */
-const IMAGE_EXTENSIONS = new Set([
+const IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
 	".jpg",
 	".jpeg",
 	".png",
@@ -1296,7 +1522,7 @@ const IMAGE_EXTENSIONS = new Set([
 	".webp",
 	".bmp"
 ]);
-const VIDEO_EXTENSIONS = new Set([
+const VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([
 	".mp4",
 	".mov",
 	".avi",
@@ -1358,7 +1584,7 @@ async function sendText(ctx) {
 	initApiConfig(account.appId, { markdownSupport: account.markdownSupport });
 	debugLog("[qqbot] sendText ctx:", JSON.stringify({
 		to,
-		text: text?.slice(0, 50),
+		text: truncateUtf16Safe(text, 50),
 		replyToId,
 		accountId: account.accountId
 	}, null, 2));
@@ -1435,7 +1661,10 @@ async function sendText(ctx) {
 		const mediaTarget = buildMediaTarget({
 			to,
 			account,
-			replyToId
+			replyToId,
+			mediaAccess: ctx.mediaAccess,
+			mediaLocalRoots: ctx.mediaLocalRoots,
+			mediaReadFile: ctx.mediaReadFile
 		});
 		let lastResult = { channel: "qqbot" };
 		for (const item of sendQueue) try {
@@ -1453,7 +1682,7 @@ async function sendText(ctx) {
 					timestamp: result.timestamp,
 					refIdx: result.ext_info?.ref_idx
 				};
-				debugLog(`[qqbot] sendText: Sent text part: ${item.content.slice(0, 30)}...`);
+				debugLog(`[qqbot] sendText: Sent text part: ${truncateUtf16Safe(item.content, 30)}...`);
 			} else if (item.type === "image") lastResult = await sendPhoto(mediaTarget, item.content);
 			else if (item.type === "voice") lastResult = await sendVoice(mediaTarget, item.content, void 0, account.config?.audioFormatPolicy?.transcodeEnabled !== false);
 			else if (item.type === "video") lastResult = await sendVideoMsg(mediaTarget, item.content);
@@ -1464,7 +1693,10 @@ async function sendText(ctx) {
 				mediaUrl: item.content,
 				accountId: account.accountId,
 				replyToId,
-				account
+				account,
+				mediaAccess: ctx.mediaAccess,
+				mediaLocalRoots: ctx.mediaLocalRoots,
+				mediaReadFile: ctx.mediaReadFile
 			});
 		} catch (err) {
 			const errMsg = formatErrorMessage(err);
@@ -1526,17 +1758,27 @@ async function sendMedia(ctx) {
 		channel: "qqbot",
 		error: "mediaUrl is required for sendMedia"
 	};
-	const resolvedMediaPath = resolveOutboundMediaPath(ctx.mediaUrl, "media", { allowMissingLocalPath: true });
+	const target = buildMediaTarget({
+		to,
+		account,
+		replyToId,
+		mediaAccess: ctx.mediaAccess,
+		mediaLocalRoots: ctx.mediaLocalRoots,
+		mediaReadFile: ctx.mediaReadFile
+	});
+	const resolvedMediaPath = !ctx.mediaAccess?.readFile && !ctx.mediaReadFile ? resolveOutboundMediaPath(ctx.mediaUrl, "media", {
+		allowMissingLocalPath: true,
+		extraLocalRoots: target.mediaLocalRoots ? [...target.mediaLocalRoots] : void 0,
+		workspaceDir: target.mediaAccess?.workspaceDir
+	}) : {
+		ok: true,
+		mediaPath: ctx.mediaUrl
+	};
 	if (!resolvedMediaPath.ok) return {
 		channel: "qqbot",
 		error: resolvedMediaPath.error
 	};
 	const mediaUrl = resolvedMediaPath.mediaPath;
-	const target = buildMediaTarget({
-		to,
-		account,
-		replyToId
-	});
 	if (isAudioFile(mediaUrl, mimeType)) {
 		const result = await sendVoice(target, mediaUrl, account.config?.audioFormatPolicy?.uploadDirectFormats ?? account.config?.voiceDirectUploadFormats, account.config?.audioFormatPolicy?.transcodeEnabled !== false);
 		if (!result.error) {
@@ -1561,7 +1803,7 @@ async function sendMedia(ctx) {
 		return result;
 	}
 	if (!isImageFile(mediaUrl, mimeType) && !isAudioFile(mediaUrl, mimeType) && !isVideoFile(mediaUrl, mimeType)) {
-		const result = await sendDocument(target, mediaUrl);
+		const result = await sendAutoDetectedMedia(target, mediaUrl);
 		if (!result.error && text?.trim()) await sendTextAfterMedia(target, text);
 		return result;
 	}
@@ -1622,4 +1864,4 @@ async function sendCronMessage(account, to, message) {
 	});
 }
 //#endregion
-export { getHomeDir as A, getMessageReplyConfig as C, OUTBOUND_ERROR_CODES as D, DEFAULT_MEDIA_SEND_ERROR as E, isLocalPath as F, isWindows as I, normalizePath$1 as L, getQQBotMediaDir as M, getQQBotMediaPath as N, setOutboundAudioPort as O, getTempDir as P, checkMessageReplyLimit as S, recordMessageReply as T, sendVideoMsg as _, sendText as a, resolveUserFacingMediaError as b, isCronReminderPayload as c, normalizeMediaTags as d, buildMediaTarget as f, sendPhoto as g, sendDocument as h, sendProactiveMessage as i, getQQBotDataDir as j, checkSilkWasmAvailable as k, isMediaPayload as l, resolveOutboundMediaPath as m, sendCronMessage as n, decodeMediaPath as o, parseTarget as p, sendMedia as r, encodePayloadForCron as s, outbound_exports as t, parseQQBotPayload as u, sendVoice as v, getMessageReplyStats as w, MESSAGE_REPLY_LIMIT as x, resolveTrustedOutboundMediaPath as y };
+export { OUTBOUND_ERROR_CODES as A, normalizePath$1 as B, resolveUserFacingMediaError as C, getMessageReplyStats as D, getMessageReplyConfig as E, getQQBotMediaDir as F, getQQBotMediaPath as I, getTempDir as L, checkSilkWasmAvailable as M, getHomeDir as N, recordMessageReply as O, getQQBotDataDir as P, isLocalPath as R, resolveWorkspaceScopedLocalRoots as S, checkMessageReplyLimit as T, sendVideoMsg as _, sendText as a, resolveOutboundMediaLocalRoots as b, isCronReminderPayload as c, normalizeMediaTags as d, buildMediaTarget as f, sendPhoto as g, sendDocument as h, sendProactiveMessage as i, setOutboundAudioPort as j, DEFAULT_MEDIA_SEND_ERROR as k, isMediaPayload as l, resolveOutboundMediaPath as m, sendCronMessage as n, decodeMediaPath as o, parseTarget as p, sendMedia as r, encodePayloadForCron as s, outbound_exports as t, parseQQBotPayload as u, sendVoice as v, MESSAGE_REPLY_LIMIT as w, resolveWorkspacePathCandidates as x, resolveTrustedOutboundMediaPath as y, isWindows as z };