@openclaw/qqbot 2026.5.2 → 2026.5.3-beta.1

package/dist/setup-entry.js

@@ -0,0 +1,15 @@
+import { defineBundledChannelSetupEntry } from "openclaw/plugin-sdk/channel-entry-contract";
+//#region extensions/qqbot/setup-entry.ts
+var setup_entry_default = defineBundledChannelSetupEntry({
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./setup-plugin-api.js",
+		exportName: "qqbotSetupPlugin"
+	},
+	secrets: {
+		specifier: "./secret-contract-api.js",
+		exportName: "channelSecrets"
+	}
+});
+//#endregion
+export { setup_entry_default as default };

package/dist/setup-plugin-api.js

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

package/dist/string-normalize-Ci6NM5DE.js

@@ -0,0 +1,98 @@
+//#region extensions/qqbot/src/engine/adapter/index.ts
+let _adapter = null;
+let _adapterFactory = null;
+/** Register the platform adapter. Called once during startup. */
+function registerPlatformAdapter(adapter) {
+	_adapter = adapter;
+}
+/**
+* Register a factory that creates the PlatformAdapter on first access.
+*
+* This decouples adapter availability from side-effect import ordering.
+* The factory is invoked at most once — on the first `getPlatformAdapter()`
+* call when no adapter has been explicitly registered yet.
+*/
+function registerPlatformAdapterFactory(factory) {
+	_adapterFactory = factory;
+}
+/**
+* Get the registered platform adapter.
+*
+* If no adapter has been explicitly registered yet but a factory was provided
+* via `registerPlatformAdapterFactory()`, the factory is invoked to create
+* and register the adapter automatically.
+*/
+function getPlatformAdapter() {
+	if (!_adapter && _adapterFactory) _adapter = _adapterFactory();
+	if (!_adapter) throw new Error("PlatformAdapter not registered. Call registerPlatformAdapter() during bootstrap.");
+	return _adapter;
+}
+/** Check whether a platform adapter has been registered (or can be created from a factory). */
+function hasPlatformAdapter() {
+	return _adapter !== null || _adapterFactory !== null;
+}
+//#endregion
+//#region extensions/qqbot/src/engine/utils/string-normalize.ts
+/**
+* String normalization and record-coercion helpers.
+*
+* These are self-contained re-implementations of the functions that
+* the plugin previously imported from `openclaw/plugin-sdk/text-runtime`
+* and `openclaw/plugin-sdk/text-runtime` (via record-coerce / string-coerce).
+*
+* core/ modules use these instead of importing plugin-sdk, keeping the
+* shared layer portable between the built-in and standalone versions.
+*/
+/** Return the trimmed string or `null` when the value is not a non-empty string. */
+function normalizeNullableString(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : null;
+}
+/** Return the trimmed string or `undefined` when the value is not a non-empty string. */
+function normalizeOptionalString(value) {
+	return normalizeNullableString(value) ?? void 0;
+}
+/**
+* Stringify then normalize.  Accepts `string | number | boolean | bigint`.
+* Returns `undefined` for objects, arrays, null, and undefined.
+*/
+function normalizeStringifiedOptionalString(value) {
+	if (typeof value === "string") return normalizeOptionalString(value);
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return normalizeOptionalString(String(value));
+}
+/** Return the trimmed lowercase string or `undefined`. */
+function normalizeOptionalLowercaseString(value) {
+	return normalizeOptionalString(value)?.toLowerCase();
+}
+/** Return the trimmed lowercase string or `""`. */
+function normalizeLowercaseStringOrEmpty(value) {
+	return normalizeOptionalLowercaseString(value) ?? "";
+}
+/** Coerce a value into a `Record<string, unknown>` or `undefined`. */
+function asOptionalObjectRecord(value) {
+	return value && typeof value === "object" ? value : void 0;
+}
+/** Read a string field from a record. */
+function readStringField(record, key) {
+	const v = record?.[key];
+	return typeof v === "string" ? v : void 0;
+}
+/**
+* Normalize filenames into a UTF-8 form that the QQ Bot API accepts reliably.
+*
+* Decodes percent-escaped names, converts Unicode to NFC, and strips
+* ASCII control characters.
+*/
+function sanitizeFileName(name) {
+	if (!name) return name;
+	let result = name.trim();
+	if (result.includes("%")) try {
+		result = decodeURIComponent(result);
+	} catch {}
+	result = result.normalize("NFC");
+	result = result.replace(/\p{Cc}/gu, "");
+	return result;
+}
+//#endregion
+export { normalizeStringifiedOptionalString as a, getPlatformAdapter as c, registerPlatformAdapterFactory as d, normalizeOptionalString as i, hasPlatformAdapter as l, normalizeLowercaseStringOrEmpty as n, readStringField as o, normalizeOptionalLowercaseString as r, sanitizeFileName as s, asOptionalObjectRecord as t, registerPlatformAdapter as u };

package/dist/target-parser-Y0prnrXD.js

@@ -0,0 +1,245 @@
+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 * as fs$1 from "node:fs";
+import * as os$1 from "node:os";
+import * as path$1 from "node:path";
+//#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 home directory safely across platforms.
+*
+* Priority:
+* 1. `os.homedir()`
+* 2. `$HOME` or `%USERPROFILE%`
+* 3. PlatformAdapter.getTempDir() as a last resort
+*/
+function getHomeDir() {
+	try {
+		const home = os$1.homedir();
+		if (home && fs$1.existsSync(home)) return home;
+	} catch {}
+	const envHome = process.env.HOME || process.env.USERPROFILE;
+	if (envHome && fs$1.existsSync(envHome)) return envHome;
+	return getPlatformAdapter().getTempDir();
+}
+/** Return a path under `~/.openclaw/qqbot` without creating it. */
+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$1.existsSync(dir)) fs$1.mkdirSync(dir, { recursive: true });
+	return dir;
+}
+/**
+* Return a path under `~/.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.
+*/
+function getQQBotMediaPath(...subPaths) {
+	return path$1.join(getHomeDir(), ".openclaw", "media", "qqbot", ...subPaths);
+}
+/** Return a path under `~/.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 });
+	return dir;
+}
+/**
+* Return `~/.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.
+*/
+function getOpenClawMediaDir() {
+	return path$1.join(getHomeDir(), ".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(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(p) {
+	let result = p.trim();
+	if (result.startsWith("file://")) {
+		result = result.slice(7);
+		try {
+			result = decodeURIComponent(result);
+		} catch {}
+	}
+	return expandTilde(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(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(p);
+	if (!isLocalPath(normalized) || fs$1.existsSync(normalized)) return normalized;
+	const homeDir = getHomeDir();
+	const mediaRoot = getQQBotMediaPath();
+	const dataRoot = getQQBotDataPath();
+	const candidateRoots = [
+		{
+			from: path$1.join(homeDir, ".openclaw", "workspace", "qqbot"),
+			to: mediaRoot
+		},
+		{
+			from: dataRoot,
+			to: mediaRoot
+		},
+		{
+			from: mediaRoot,
+			to: dataRoot
+		}
+	];
+	for (const { from, to } of candidateRoots) {
+		if (!isPathWithinRoot(normalized, from)) continue;
+		const relative = path$1.relative(from, normalized);
+		const candidate = path$1.join(to, relative);
+		if (fs$1.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$1.existsSync(resolvedCandidate)) return null;
+	const canonicalCandidate = fs$1.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;
+	}
+	return null;
+}
+//#endregion
+//#region extensions/qqbot/src/engine/messaging/target-parser.ts
+/**
+* Parse a qqbot target string into a structured delivery target.
+*
+* Supported formats:
+* - `qqbot:c2c:openid` → C2C direct message
+* - `qqbot:group:groupid` → Group message
+* - `qqbot:channel:channelid` → Channel message
+* - `c2c:openid` → C2C (without qqbot: prefix)
+* - `group:groupid` → Group (without qqbot: prefix)
+* - `channel:channelid` → Channel (without qqbot: prefix)
+* - `openid` → C2C (bare openid, default)
+*
+* @param to - Raw target string.
+* @returns Parsed target with type and id.
+* @throws {Error} When the target format is invalid.
+*/
+function parseTarget(to) {
+	let id = to.replace(/^qqbot:/i, "");
+	if (id.startsWith("c2c:")) {
+		const userId = id.slice(4);
+		if (!userId) throw new Error(`Invalid c2c target format: ${to} - missing user ID`);
+		return {
+			type: "c2c",
+			id: userId
+		};
+	}
+	if (id.startsWith("group:")) {
+		const groupId = id.slice(6);
+		if (!groupId) throw new Error(`Invalid group target format: ${to} - missing group ID`);
+		return {
+			type: "group",
+			id: groupId
+		};
+	}
+	if (id.startsWith("channel:")) {
+		const channelId = id.slice(8);
+		if (!channelId) throw new Error(`Invalid channel target format: ${to} - missing channel ID`);
+		return {
+			type: "channel",
+			id: channelId
+		};
+	}
+	if (!id) throw new Error(`Invalid target format: ${to} - empty ID after removing qqbot: prefix`);
+	return {
+		type: "c2c",
+		id
+	};
+}
+/**
+* Normalize a QQ Bot target string into the canonical `qqbot:...` form.
+*
+* Returns `undefined` when the target does not look like a QQ Bot address.
+*/
+function normalizeTarget(target) {
+	const id = target.replace(/^qqbot:/i, "");
+	if (id.startsWith("c2c:") || id.startsWith("group:") || id.startsWith("channel:")) return `qqbot:${id}`;
+	if (/^[0-9a-fA-F]{32}$/.test(id)) return `qqbot:c2c:${id}`;
+	if (/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(id)) return `qqbot:c2c:${id}`;
+}
+/**
+* Return true when the string looks like a QQ Bot target ID.
+*/
+function looksLikeQQBotTarget(id) {
+	if (/^qqbot:(c2c|group|channel):/i.test(id)) return true;
+	if (/^(c2c|group|channel):/i.test(id)) return true;
+	if (/^[0-9a-fA-F]{32}$/.test(id)) return true;
+	return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(id);
+}
+//#endregion
+export { getHomeDir as a, getQQBotMediaDir as c, isLocalPath as d, isWindows as f, checkSilkWasmAvailable as i, getQQBotMediaPath as l, resolveQQBotPayloadLocalFilePath as m, normalizeTarget as n, getQQBotDataDir as o, normalizePath as p, parseTarget as r, getQQBotDataPath as s, looksLikeQQBotTarget as t, getTempDir as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/qqbot",
-  "version": "2026.5.2",
+  "version": "2026.5.3-beta.1",
   "private": false,
   "description": "OpenClaw QQ Bot channel plugin",
   "repository": {
@@ -21,7 +21,7 @@
     "openclaw": "workspace:*"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.5.2"
+    "openclaw": ">=2026.5.3-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -50,14 +50,23 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.5.2"
+      "pluginApi": ">=2026.5.3-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.5.2"
+      "openclawVersion": "2026.5.3-beta.1"
     },
     "release": {
       "publishToClawHub": true,
       "publishToNpm": true
-    }
-  }
+    },
+    "runtimeExtensions": [
+      "./dist/index.js"
+    ],
+    "runtimeSetupEntry": "./dist/setup-entry.js"
+  },
+  "files": [
+    "dist/**",
+    "openclaw.plugin.json",
+    "skills/**"
+  ]
 }

package/api.ts

@@ -1,56 +0,0 @@
-export { qqbotPlugin } from "./src/channel.js";
-export { qqbotSetupPlugin } from "./src/channel.setup.js";
-export { getFrameworkCommands } from "./src/engine/commands/slash-commands-impl.js";
-export { registerChannelTool } from "./src/bridge/tools/channel.js";
-export { registerRemindTool } from "./src/bridge/tools/remind.js";
-export { registerQQBotTools } from "./src/bridge/tools/index.js";
-export { registerQQBotFull } from "./src/bridge/channel-entry.js";
-export {
-  type AudioFormatPolicy,
-  type C2CMessageEvent,
-  type GroupMessageEvent,
-  type GuildMessageEvent,
-  type MessageAttachment,
-  type QQBotAccountConfig,
-  type QQBotConfig,
-  type QQBotDmPolicy,
-  type QQBotExecApprovalConfig,
-  type QQBotGroupPolicy,
-  type ResolvedQQBotAccount,
-  type WSPayload,
-} from "./src/types.js";
-export {
-  applyQQBotAccountConfig,
-  DEFAULT_ACCOUNT_ID,
-  listQQBotAccountIds,
-  resolveDefaultQQBotAccountId,
-  resolveQQBotAccount,
-} from "./src/bridge/config.js";
-export {
-  buildMediaTarget,
-  checkMessageReplyLimit,
-  DEFAULT_MEDIA_SEND_ERROR,
-  getMessageReplyConfig,
-  getMessageReplyStats,
-  type MediaOutboundContext,
-  type MediaTargetContext,
-  MESSAGE_REPLY_LIMIT,
-  OUTBOUND_ERROR_CODES,
-  type OutboundContext,
-  type OutboundErrorCode,
-  type OutboundResult,
-  parseTarget,
-  recordMessageReply,
-  type ReplyLimitResult,
-  resolveOutboundMediaPath,
-  resolveUserFacingMediaError,
-  sendCronMessage,
-  sendDocument,
-  sendMedia,
-  sendPhoto,
-  sendProactiveMessage,
-  sendText,
-  sendVideoMsg,
-  sendVoice,
-  setOutboundAudioPort,
-} from "./src/engine/messaging/outbound.js";

package/channel-plugin-api.ts

@@ -1 +0,0 @@
-export { qqbotPlugin } from "./src/channel.js";

package/index.ts

@@ -1,29 +0,0 @@
-import {
-  defineBundledChannelEntry,
-  loadBundledEntryExportSync,
-  type OpenClawPluginApi,
-} from "openclaw/plugin-sdk/channel-entry-contract";
-
-function registerQQBotFull(api: OpenClawPluginApi): void {
-  const register = loadBundledEntryExportSync<(api: OpenClawPluginApi) => void>(import.meta.url, {
-    specifier: "./api.js",
-    exportName: "registerQQBotFull",
-  });
-  register(api);
-}
-
-export default defineBundledChannelEntry({
-  id: "qqbot",
-  name: "QQ Bot",
-  description: "QQ Bot channel plugin",
-  importMetaUrl: import.meta.url,
-  plugin: {
-    specifier: "./channel-plugin-api.js",
-    exportName: "qqbotPlugin",
-  },
-  runtime: {
-    specifier: "./runtime-api.js",
-    exportName: "setQQBotRuntime",
-  },
-  registerFull: registerQQBotFull,
-});

package/runtime-api.ts

@@ -1,9 +0,0 @@
-export type { ChannelPlugin, OpenClawPluginApi, PluginRuntime } from "openclaw/plugin-sdk/core";
-export type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-export type {
-  OpenClawPluginService,
-  OpenClawPluginServiceContext,
-  PluginLogger,
-} from "openclaw/plugin-sdk/core";
-export type { ResolvedQQBotAccount, QQBotAccountConfig } from "./src/types.js";
-export { getQQBotRuntime, setQQBotRuntime } from "./src/bridge/runtime.js";

package/setup-entry.ts

@@ -1,9 +0,0 @@
-import { defineBundledChannelSetupEntry } from "openclaw/plugin-sdk/channel-entry-contract";
-
-export default defineBundledChannelSetupEntry({
-  importMetaUrl: import.meta.url,
-  plugin: {
-    specifier: "./setup-plugin-api.js",
-    exportName: "qqbotSetupPlugin",
-  },
-});

package/setup-plugin-api.ts

@@ -1,3 +0,0 @@
-// Keep bundled setup entry imports narrow so setup loads do not pull the
-// broader QQ Bot runtime plugin surface.
-export { qqbotSetupPlugin } from "./src/channel.setup.js";