@openclaw/qqbot 2026.6.11 → 2026.7.1-beta.2

package/dist/{outbound-BQcPCo-z.js → outbound-BZHwMFUX.js}

@@ -1,11 +1,226 @@
-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-CRZ2af7P.js";
-import { i as normalizeOptionalString, n as normalizeLowercaseStringOrEmpty, s as sanitizeFileName } from "./string-normalize-R_0cKO7Q.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-BfVLJJYp.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 { c as getQQBotMediaDir, d as isLocalPath, m as resolveQQBotPayloadLocalFilePath, o as getQQBotDataDir, p as normalizePath$1, r as parseTarget$1 } from "./target-parser-BdCUmxK7.js";
+import { r as parseTarget$1 } from "./target-parser-DagYRQkP.js";
+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
+/**
+* Cross-platform path and detection helpers for core/ modules.
+*
+* Provides home/data/media directory helpers, platform detection,
+* silk-wasm availability checks — all without importing `openclaw/plugin-sdk`.
+* The temp-directory fallback is delegated to the PlatformAdapter.
+*/
+/**
+* Resolve the current user's OS home directory safely across platforms.
+*
+* Priority:
+* 1. `os.homedir()`
+* 2. `$HOME` or `%USERPROFILE%`
+* 3. PlatformAdapter.getTempDir() as a last resort
+*
+* This is the *operating-system* home and intentionally ignores
+* `OPENCLAW_HOME`. QQ Bot still checks this tree for legacy state imports and
+* media-path remaps from older releases.
+*/
+function getHomeDir() {
+	try {
+		const home = os$1.homedir();
+		if (home && fs$2.existsSync(home)) return home;
+	} catch {}
+	const envHome = process.env.HOME || process.env.USERPROFILE;
+	if (envHome && fs$2.existsSync(envHome)) return envHome;
+	return getPlatformAdapter().getTempDir();
+}
+/**
+* Resolve the effective OpenClaw home directory.
+*
+* Mirrors the contract from core (`src/infra/home-dir.ts::resolveEffectiveHomeDir`)
+* so QQ Bot media roots live under the same tree the rest of OpenClaw treats as
+* `~`. The extension cannot import the core helper directly (it is a separate
+* package with `openclaw` as a peer dependency), so this re-implements the
+* minimal contract:
+*
+* 1. `OPENCLAW_HOME` when set (with `~` / `~/...` expanded against the OS home).
+* 2. Otherwise fall back to {@link getHomeDir} so existing single-home
+*    deployments are unaffected.
+*
+* Empty / `"undefined"` / `"null"` strings are treated as unset to match how
+* core normalizes the variable.
+*/
+function resolveOpenClawHome() {
+	const raw = process.env.OPENCLAW_HOME?.trim();
+	if (!raw || raw === "undefined" || raw === "null") return getHomeDir();
+	if (raw === "~" || raw.startsWith("~/") || raw.startsWith("~\\")) {
+		const osHome = getHomeDir();
+		if (raw === "~") return osHome;
+		return path$1.join(osHome, raw.slice(2));
+	}
+	return raw;
+}
+/**
+* Return a legacy path under `~/.openclaw/qqbot` without creating it.
+*
+* Current QQ Bot runtime state lives in plugin SQLite KV. This path remains for
+* legacy imports and media-path remaps from older releases.
+*/
+function getQQBotDataPath(...subPaths) {
+	return path$1.join(getHomeDir(), ".openclaw", "qqbot", ...subPaths);
+}
+/** Return a path under `~/.openclaw/qqbot`, creating it on demand. */
+function getQQBotDataDir(...subPaths) {
+	const dir = getQQBotDataPath(...subPaths);
+	if (!fs$2.existsSync(dir)) fs$2.mkdirSync(dir, { recursive: true });
+	return dir;
+}
+/**
+* Return a path under `<openclaw-home>/.openclaw/media/qqbot` without creating it.
+*
+* Unlike `getQQBotDataPath`, this lives under OpenClaw's core media allowlist
+* so downloaded images and audio can be accessed by framework media tooling.
+* The base honors `OPENCLAW_HOME` (when set) so files written by agents into
+* the OpenClaw-managed media tree are reachable by this plugin even when
+* `HOME` and `OPENCLAW_HOME` differ (Docker, multi-user hosts). Fixes #83562.
+*/
+function getQQBotMediaPath(...subPaths) {
+	return path$1.join(resolveOpenClawHome(), ".openclaw", "media", "qqbot", ...subPaths);
+}
+/** Return a path under `<openclaw-home>/.openclaw/media/qqbot`, creating it on demand. */
+function getQQBotMediaDir(...subPaths) {
+	const dir = getQQBotMediaPath(...subPaths);
+	if (!fs$2.existsSync(dir)) fs$2.mkdirSync(dir, { recursive: true });
+	return dir;
+}
+/**
+* Return `<openclaw-home>/.openclaw/media`, OpenClaw's shared media root.
+*
+* This mirrors the directory that core's `buildMediaLocalRoots` exposes as an
+* allowlisted location (see `openclaw/src/media/local-roots.ts`). Using it as a
+* QQ Bot payload root lets the plugin trust framework-produced files that live
+* in sibling subdirectories such as `outbound/` (written by
+* `saveMediaBuffer(..., "outbound", ...)`) or `inbound/`, while still keeping
+* the check anchored to a single, well-known directory. Like
+* {@link getQQBotMediaPath}, the base honors `OPENCLAW_HOME`.
+*/
+function getOpenClawMediaDir() {
+	return path$1.join(resolveOpenClawHome(), ".openclaw", "media");
+}
+function isWindows() {
+	return process.platform === "win32";
+}
+/** Return the preferred temporary directory. */
+function getTempDir() {
+	return getPlatformAdapter().getTempDir();
+}
+let silkWasmAvailable = null;
+/** Check whether silk-wasm can run in the current environment. */
+async function checkSilkWasmAvailable() {
+	if (silkWasmAvailable !== null) return silkWasmAvailable;
+	try {
+		const { isSilk } = await import("silk-wasm");
+		isSilk(new Uint8Array(0));
+		silkWasmAvailable = true;
+		debugLog("[platform] silk-wasm: available");
+	} catch (err) {
+		silkWasmAvailable = false;
+		debugWarn(`[platform] silk-wasm: NOT available (${formatErrorMessage(err)})`);
+	}
+	return silkWasmAvailable;
+}
+/** Expand `~` to the current user's home directory. */
+function expandTilde$1(p) {
+	if (!p) return p;
+	if (p === "~") return getHomeDir();
+	if (p.startsWith("~/") || p.startsWith("~\\")) return path$1.join(getHomeDir(), p.slice(2));
+	return p;
+}
+/** Normalize a user-provided path by trimming, stripping `file://`, and expanding `~`. */
+function normalizePath$1(p) {
+	let result = p.trim();
+	if (result.startsWith("file://")) {
+		result = result.slice(7);
+		try {
+			result = decodeURIComponent(result);
+		} catch {}
+	}
+	return expandTilde$1(result);
+}
+/** Return true when the string looks like a local filesystem path rather than a URL. */
+function isLocalPath(p) {
+	if (!p) return false;
+	if (p.startsWith("file://")) return true;
+	if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) return true;
+	if (p.startsWith("/")) return true;
+	if (/^[a-zA-Z]:[\\/]/.test(p)) return true;
+	if (p.startsWith("\\\\")) return true;
+	if (p.startsWith("./") || p.startsWith("../")) return true;
+	if (p.startsWith(".\\") || p.startsWith("..\\")) return true;
+	return false;
+}
+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$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) => ({
+			from,
+			to: mediaRoot
+		})),
+		{
+			from: dataRoot,
+			to: mediaRoot
+		},
+		{
+			from: mediaRoot,
+			to: dataRoot
+		}
+	];
+	for (const { from, to } of candidateRoots) {
+		if (!isPathWithinRoot$1(normalized, from)) continue;
+		const relative = path$1.relative(from, normalized);
+		const candidate = path$1.join(to, relative);
+		if (fs$2.existsSync(candidate)) {
+			debugWarn(`[platform] Remapped missing QQBot media path ${normalized} -> ${candidate}`);
+			return candidate;
+		}
+	}
+	return normalized;
+}
+/**
+* Resolve a structured-payload local file path and enforce that it stays within
+* QQ Bot-owned storage roots.
+*/
+function resolveQQBotPayloadLocalFilePath(p) {
+	const candidate = resolveQQBotLocalMediaPath(p);
+	if (!candidate.trim()) return null;
+	const resolvedCandidate = path$1.resolve(candidate);
+	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$1(canonicalCandidate, fs$2.existsSync(resolvedRoot) ? fs$2.realpathSync(resolvedRoot) : resolvedRoot)) return canonicalCandidate;
+	}
+	return null;
+}
+//#endregion
 //#region extensions/qqbot/src/engine/messaging/outbound-audio-port.ts
 let outboundAudioPort = null;
 /**
@@ -194,6 +409,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() {
@@ -250,11 +505,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. */
@@ -268,19 +527,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,
@@ -288,30 +556,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 {
@@ -323,15 +727,20 @@ 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");
@@ -451,13 +860,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 = {
@@ -504,7 +929,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 {
@@ -567,13 +993,18 @@ 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");
@@ -675,13 +1106,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...`);
@@ -706,7 +1142,7 @@ async function sendDocument(ctx, filePath, options = {}) {
 					kind: "file",
 					source: { url: mediaPath },
 					msgId: ctx.replyToId,
-					fileName
+					...fileName ? { fileName } : {}
 				});
 				return {
 					channel: "qqbot",
@@ -1223,7 +1659,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 {
@@ -1252,7 +1691,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);
@@ -1314,17 +1756,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) {
@@ -1349,7 +1801,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;
 	}
@@ -1410,4 +1862,4 @@ async function sendCronMessage(account, to, message) {
 	});
 }
 //#endregion
-export { getMessageReplyConfig as C, OUTBOUND_ERROR_CODES as D, DEFAULT_MEDIA_SEND_ERROR as E, setOutboundAudioPort as O, 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, 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 };