@xmoxmo/bncr 0.6.9 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmoxmo/bncr",
-  "version": "0.6.9",
+  "version": "0.7.1",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -27,6 +27,7 @@
   "scripts": {
     "build": "npx -y esbuild@0.28.0 index.ts --bundle --platform=node --format=esm --target=node22 --packages=external --outfile=dist/index.js",
     "selfcheck": "node ./scripts/selfcheck.mjs",
+    "selfcheck:release": "node ./scripts/selfcheck.mjs --release",
     "test": "node --import ./tests/register-ts-hooks.mjs --test ./tests/**/*.test.mjs",
     "check-register-drift": "node ./scripts/check-register-drift.mjs",
     "check-pack": "node ./scripts/check-pack.mjs",

package/scripts/check-pack.mjs

@@ -13,6 +13,7 @@ const requiredScriptFiles = [
   'scripts/check-pack.mjs',
   'scripts/check-register-drift.mjs',
   'scripts/selfcheck.mjs',
+  'scripts/version-policy.mjs',
 ];
 
 const requiredSourceFiles = [

package/scripts/selfcheck.mjs

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { validateReleaseVersionPolicy, validateVersionSyntax } from './version-policy.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -10,6 +11,7 @@ const root = path.resolve(__dirname, '..');
 const require = createRequire(import.meta.url);
 
 const requiredRootFiles = ['index.ts', 'openclaw.plugin.json'];
+const requiredScriptFiles = ['scripts/version-policy.mjs'];
 
 const requiredSourceFiles = [
   'src/bootstrap/channel-plugin-runtime.ts',
@@ -213,7 +215,7 @@ const requiredSourceFiles = [
   'src/runtime/status-worker.ts',
 ];
 
-const requiredFiles = [...requiredRootFiles, ...requiredSourceFiles];
+const requiredFiles = [...requiredRootFiles, ...requiredScriptFiles, ...requiredSourceFiles];
 
 const readPackageVersion = () => {
   const pkgPath = path.join(root, 'package.json');
@@ -238,17 +240,17 @@ const readNpmLatestVersion = (packageName) => {
 const requiredOpenClawSdkSubpaths = [
   'openclaw/plugin-sdk/channel-outbound',
   'openclaw/plugin-sdk/channel-ingress-runtime',
-  'openclaw/plugin-sdk/channel-message',
   'openclaw/plugin-sdk/routing',
   'openclaw/plugin-sdk/conversation-runtime',
   'openclaw/plugin-sdk/session-store-runtime',
   'openclaw/plugin-sdk/core',
   'openclaw/plugin-sdk/json-store',
   'openclaw/plugin-sdk/param-readers',
+  'openclaw/plugin-sdk/media-runtime',
   'openclaw/plugin-sdk/security-runtime',
   'openclaw/plugin-sdk/status-helpers',
   'openclaw/plugin-sdk/tool-send',
-  'openclaw/plugin-sdk/command-auth',
+  'openclaw/plugin-sdk/command-detection',
   'openclaw/plugin-sdk/reply-history',
 ];
 
@@ -266,120 +268,14 @@ const resolveOpenClawSdkSubpaths = () => {
   });
 };
 
-const validateVersionPolicy = (version, latestVersion) => {
-  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
-  if (!match) {
-    return {
-      ok: false,
-      reason: 'version must be strict semver x.y.z',
-      version,
-    };
-  }
-
-  const patch = Number.parseInt(match[3], 10);
-  if (patch > 9) {
-    return {
-      ok: false,
-      reason: 'patch version must stay within 0-9; bump minor instead',
-      version,
-    };
-  }
-
-  // Prevent jumping minor when current minor still has unused patch slots
-  if (latestVersion) {
-    const lm = latestVersion.match(/^(\d+)\.(\d+)\.(\d+)$/);
-    if (lm) {
-      const vMajor = Number.parseInt(match[1], 10);
-      const vMinor = Number.parseInt(match[2], 10);
-      const lMajor = Number.parseInt(lm[1], 10);
-      const lMinor = Number.parseInt(lm[2], 10);
-      const lPatch = Number.parseInt(lm[3], 10);
-
-      // Version unchanged
-      if (vMajor === lMajor && vMinor === lMinor && patch === lPatch) {
-        return { ok: false, reason: `version unchanged: ${version}`, version };
-      }
-
-      // Downgrade: any component decreased
-      if (
-        vMajor < lMajor ||
-        (vMajor === lMajor && vMinor < lMinor) ||
-        (vMajor === lMajor && vMinor === lMinor && patch < lPatch)
-      ) {
-        return { ok: false, reason: `downgrade from ${latestVersion} to ${version}`, version };
-      }
-
-      // Patch bump: same major and minor, patch must increment by exactly +1
-      if (vMajor === lMajor && vMinor === lMinor) {
-        if (patch === lPatch + 1) return { ok: true, version };
-        return {
-          ok: false,
-          reason: `patch jump from ${latestVersion} to ${version} (delta=${patch - lPatch}); expected ${lMajor}.${lMinor}.${lPatch + 1}`,
-          version,
-        };
-      }
-
-      // Minor bump: same major, minor + 1
-      if (vMajor === lMajor && vMinor === lMinor + 1) {
-        if (lPatch === 9 && patch === 0) return { ok: true, version };
-        if (lPatch !== 9)
-          return {
-            ok: false,
-            reason: `minor bumped from ${latestVersion} to ${version} but ${9 - lPatch} patch slots remain in ${lMajor}.${lMinor}; prefer ${lMajor}.${lMinor}.${lPatch + 1}`,
-            version,
-          };
-        return {
-          ok: false,
-          reason: `minor bump must reset patch to 0; got ${vMajor}.${vMinor}.${patch}`,
-          version,
-        };
-      }
-
-      // Minor jumped by more than 1
-      if (vMajor === lMajor && vMinor > lMinor + 1) {
-        return {
-          ok: false,
-          reason: `minor jumped from ${latestVersion} to ${version}; expected ${lMajor}.${lMinor + 1}.0`,
-          version,
-        };
-      }
-
-      // Major bump: major + 1, requires previous minor fully exhausted
-      if (vMajor === lMajor + 1) {
-        if (lMinor === 9 && lPatch === 9 && vMinor === 0 && patch === 0)
-          return { ok: true, version };
-        if (lMinor !== 9 || lPatch !== 9)
-          return {
-            ok: false,
-            reason: `major bumped from ${latestVersion} to ${version} but previous major series not exhausted; expected ${lMajor + 1}.0.0 after ${lMajor}.9.9`,
-            version,
-          };
-        return {
-          ok: false,
-          reason: `major bump must reset to .0.0; got ${vMajor}.${vMinor}.${patch}`,
-          version,
-        };
-      }
-
-      // Major jumped by more than 1
-      if (vMajor > lMajor + 1) {
-        return {
-          ok: false,
-          reason: `major jumped from ${latestVersion} to ${version}; expected ${lMajor + 1}.0.0`,
-          version,
-        };
-      }
-    }
-  }
-
-  return { ok: true, version };
-};
-
 const missing = requiredFiles.filter((rel) => !fs.existsSync(path.join(root, rel)));
 const version = readPackageVersion();
 const packageName = '@xmoxmo/bncr';
-const latestVersion = readNpmLatestVersion(packageName);
-const versionPolicy = validateVersionPolicy(version, latestVersion);
+const releaseMode = process.argv.includes('--release');
+const latestVersion = releaseMode ? readNpmLatestVersion(packageName) : null;
+const versionPolicy = releaseMode
+  ? validateReleaseVersionPolicy(version, latestVersion)
+  : validateVersionSyntax(version);
 const sdkSubpaths = resolveOpenClawSdkSubpaths();
 const missingSdkSubpaths = sdkSubpaths.filter((entry) => !entry.ok);
 const result = {
@@ -388,6 +284,8 @@ const result = {
   requiredCount: requiredFiles.length,
   missing,
   version,
+  versionMode: releaseMode ? 'release' : 'development',
+  latestVersion,
   versionPolicy,
   sdkSubpaths,
 };

package/scripts/version-policy.mjs

@@ -0,0 +1,75 @@
+export const validateVersionSyntax = (version) => {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!match) {
+    return {
+      ok: false,
+      reason: 'version must be strict semver x.y.z',
+      version,
+    };
+  }
+
+  const patch = Number.parseInt(match[3], 10);
+  if (patch > 9) {
+    return {
+      ok: false,
+      reason: 'patch version must stay within 0-9; bump minor instead',
+      version,
+    };
+  }
+
+  return { ok: true, version };
+};
+
+export const validateReleaseVersionPolicy = (version, latestVersion) => {
+  const versionPolicy = validateVersionSyntax(version);
+  if (!versionPolicy.ok) return versionPolicy;
+
+  if (!latestVersion) {
+    return {
+      ok: false,
+      reason: 'cannot verify release version: npm latest version is unavailable',
+      version,
+    };
+  }
+
+  const latestMatch = latestVersion.match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!latestMatch) {
+    return {
+      ok: false,
+      reason: `invalid npm latest version: ${latestVersion}`,
+      version,
+    };
+  }
+
+  const latestMajor = Number.parseInt(latestMatch[1], 10);
+  const latestMinor = Number.parseInt(latestMatch[2], 10);
+  const latestPatch = Number.parseInt(latestMatch[3], 10);
+  if (latestPatch > 9) {
+    return {
+      ok: false,
+      reason: `invalid npm latest version: patch must stay within 0-9 (${latestVersion})`,
+      version,
+    };
+  }
+
+  const expected =
+    latestPatch < 9
+      ? `${latestMajor}.${latestMinor}.${latestPatch + 1}`
+      : latestMinor < 9
+        ? `${latestMajor}.${latestMinor + 1}.0`
+        : `${latestMajor + 1}.0.0`;
+
+  if (version !== expected) {
+    return {
+      ok: false,
+      reason: `release version must be exactly one valid step after ${latestVersion}: expected ${expected}, got ${version}`,
+      version,
+    };
+  }
+
+  return {
+    ok: true,
+    mode: 'release',
+    version,
+  };
+};

package/src/channel.ts

@@ -231,6 +231,10 @@ class BncrBridgeRuntime {
   // Identity / lifecycle ----------------------------------------------------
   private api: OpenClawPluginApi;
 
+  getApi(): OpenClawPluginApi {
+    return this.api;
+  }
+
   private get runtimeApi(): OpenClawPluginApi {
     return this.api;
   }
@@ -3235,6 +3239,7 @@ export function createBncrChannelPlugin(getBridge: () => BncrBridgeRuntime) {
   return createBncrChannelPluginSurfaceGroup({
     channelId: CHANNEL_ID,
     sceneRegistry: getBridge().getSceneRegistry(),
+    getApi: () => getBridge().getApi(),
     getMessageSendBridge: bridgeGroup.getMessageSendBridge,
     getOutboundBridge: bridgeGroup.getOutboundBridge,
     getMessagingBridge: bridgeGroup.getMessagingBridge,

package/src/messaging/inbound/commands.ts

@@ -1,4 +1,4 @@
-import { hasControlCommand } from 'openclaw/plugin-sdk/command-auth';
+import { hasControlCommand } from 'openclaw/plugin-sdk/command-detection';
 import { emitBncrLogLine } from '../../core/logging.ts';
 import { resolveBncrChannelPolicy } from '../../core/policy.ts';
 import { formatDisplayScope } from '../../core/targets.ts';

package/src/messaging/inbound/dispatch-prep.ts

@@ -1,5 +1,5 @@
 import fs from 'node:fs';
-import { hasControlCommand } from 'openclaw/plugin-sdk/command-auth';
+import { hasControlCommand } from 'openclaw/plugin-sdk/command-detection';
 import {
   formatDisplayScope,
   normalizeInboundSessionKey,

package/src/messaging/inbound/dispatch.ts

@@ -271,7 +271,11 @@ export async function dispatchBncrInbound(params: {
         mediaContentType: mediaContentType || mimeType,
         historyLimit: resolvedHistoryLimit,
       });
-      if (historyKey) {
+      // A silent history flush repurposes the current turn as a context carrier
+      // and suppresses its outbound. Only a turn we would not reply to anyway
+      // may carry the flush; a reply-expected turn must reach the channel, and
+      // its backlog is flushed by the outbound path after the reply instead.
+      if (historyKey && !initialShouldDispatch && !forceSilentHistoryFlush) {
         const entries = conversationHistories.get(historyKey);
         if (entries && resolvedHistoryLimit > 0 && entries.length >= resolvedHistoryLimit) {
           const sceneForHistory = sceneRegistry.get(buildSceneKey(parsed));
@@ -279,6 +283,10 @@ export async function dispatchBncrInbound(params: {
           if (historyForce) {
             silentHistoryFlush = true;
             shouldDispatch = true;
+            emitBncrLogLine(
+              'info',
+              `history silent flush|key=${historyKey}|limit=${resolvedHistoryLimit}|entries=${entries.length}|carrier=${msgId ?? '-'}`,
+            );
           }
         }
       }

package/src/openclaw/media-runtime.ts

@@ -1,5 +1,9 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
+import { canonicalizeBase64, estimateBase64DecodedBytes } from 'openclaw/plugin-sdk/media-runtime';
+
+export const OPENCLAW_SEND_BUFFER_MEDIA_URL = 'buffer://message-send/attachment';
+export const OPENCLAW_OUTBOUND_MEDIA_MAX_BYTES = 50 * 1024 * 1024;
 
 type RuntimeMediaLoaded = {
   buffer: Buffer;
@@ -39,6 +43,114 @@ type RuntimeApiHolder = {
 
 export type OpenClawLoadedMedia = RuntimeMediaLoaded;
 
+type OpenClawSendBufferDecodeResult = {
+  buffer: Buffer;
+  mimeType?: string;
+  fileName?: string;
+};
+
+function normalizeOptionalString(value: string | undefined): string | undefined {
+  const normalized = String(value || '').trim();
+  return normalized || undefined;
+}
+
+function isPathInsideRoot(candidate: string, root: string): boolean {
+  const relative = path.relative(root, candidate);
+  return (
+    relative === '' ||
+    (relative !== '..' && !path.isAbsolute(relative) && !relative.startsWith(`..${path.sep}`))
+  );
+}
+
+/**
+ * Translate a sandbox container workspace path into an authorized host path.
+ *
+ * `extra.path` bypasses host-side sandbox staging, so a path such as
+ * `/workspace/file.js` reaches the plugin unchanged. Resolve it only against
+ * roots supplied by the host and prefer the most specific matching root.
+ */
+function resolveContainerWorkspaceMediaPath(
+  mediaUrl: string,
+  localRoots?: readonly string[],
+): string {
+  if (!localRoots?.length || !/^\/workspace(?:\/|$)/.test(mediaUrl)) {
+    return mediaUrl;
+  }
+  if (existsSync(mediaUrl)) {
+    return mediaUrl;
+  }
+
+  const relativePath = mediaUrl.slice('/workspace'.length).replace(/^\/+/, '');
+  if (!relativePath) {
+    return mediaUrl;
+  }
+
+  let bestMatch: { root: string; candidate: string } | undefined;
+  for (const root of localRoots) {
+    const resolvedRoot = path.resolve(root);
+    const candidate = path.resolve(resolvedRoot, relativePath);
+    if (!isPathInsideRoot(candidate, resolvedRoot) || !existsSync(candidate)) {
+      continue;
+    }
+    if (!bestMatch || resolvedRoot.length > bestMatch.root.length) {
+      bestMatch = { root: resolvedRoot, candidate };
+    }
+  }
+
+  return bestMatch?.candidate ?? mediaUrl;
+}
+
+export function isOpenClawSendBufferMediaUrl(mediaUrl: string): boolean {
+  return String(mediaUrl || '').trim() === OPENCLAW_SEND_BUFFER_MEDIA_URL;
+}
+
+export function decodeOpenClawSendBuffer(params: {
+  buffer: string;
+  contentType?: string;
+  mimeType?: string;
+  filename?: string;
+  fileName?: string;
+  maxBytes?: number;
+}): OpenClawSendBufferDecodeResult {
+  const raw = String(params.buffer || '').trim();
+  const match = /^data:([^;,\s]+)(;(?!base64)[^,;\s]+)*;base64,(.*)$/is.exec(raw);
+  const encoded = match ? match[3] : raw;
+  if (!encoded.trim()) {
+    throw new Error('send buffer base64 decoded to empty buffer');
+  }
+  const canonical = canonicalizeBase64(encoded);
+  if (!canonical) {
+    throw new Error('send buffer has invalid base64 data');
+  }
+
+  const maxBytes = params.maxBytes ?? OPENCLAW_OUTBOUND_MEDIA_MAX_BYTES;
+  const estimatedBytes = estimateBase64DecodedBytes(canonical);
+  if (estimatedBytes > maxBytes) {
+    throw new Error(
+      `send buffer media too large: estimated ${estimatedBytes} bytes exceeds ${maxBytes} bytes`,
+    );
+  }
+
+  const buffer = Buffer.from(canonical, 'base64');
+  if (!buffer.length) {
+    throw new Error('send buffer base64 decoded to empty buffer');
+  }
+  if (buffer.byteLength > maxBytes) {
+    throw new Error(
+      `send buffer media too large: decoded ${buffer.byteLength} bytes exceeds ${maxBytes} bytes`,
+    );
+  }
+
+  return {
+    buffer,
+    mimeType:
+      normalizeOptionalString(params.contentType) ??
+      normalizeOptionalString(params.mimeType) ??
+      normalizeOptionalString(match?.[1]),
+    fileName: normalizeOptionalString(params.filename) ?? normalizeOptionalString(params.fileName),
+  };
+}
+
 export function isOpenClawRemoteHttpMediaUrl(mediaUrl: string): boolean {
   return /^https?:\/\//i.test(String(mediaUrl || '').trim());
 }
@@ -50,6 +162,8 @@ export function isOpenClawRemoteHttpMediaUrl(mediaUrl: string): boolean {
  */
 function resolveRelativeMediaPath(mediaUrl: string, localRoots?: readonly string[]): string {
   if (!mediaUrl || !localRoots?.length) return mediaUrl;
+  const containerWorkspacePath = resolveContainerWorkspaceMediaPath(mediaUrl, localRoots);
+  if (containerWorkspacePath !== mediaUrl) return containerWorkspacePath;
   if (path.isAbsolute(mediaUrl)) return mediaUrl;
   // HTTP / file:// / data: / ~ paths are handled elsewhere
   if (/^(https?|file|data):/i.test(mediaUrl) || mediaUrl.startsWith('~')) return mediaUrl;

package/src/plugin/channel-plugin-bridge-group.ts

@@ -1,4 +1,4 @@
-import type { ChannelMessageSendResult } from 'openclaw/plugin-sdk/channel-message';
+import type { ChannelMessageSendResult } from 'openclaw/plugin-sdk/channel-outbound';
 import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
 import type { BncrRecentOutboundEntry, BncrRoute } from '../core/types.ts';
 import type { ReplyPayloadInput } from '../messaging/outbound/reply-enqueue.ts';

package/src/plugin/channel-plugin-surface-group.ts

@@ -1,4 +1,4 @@
-import type { ChannelMessageSendResult } from 'openclaw/plugin-sdk/channel-message';
+import type { ChannelMessageSendResult } from 'openclaw/plugin-sdk/channel-outbound';
 import { Type } from 'typebox';
 import { listAccountIds, normalizeAccountId, resolveAccount } from '../core/accounts.ts';
 import { BncrConfigSchema } from '../core/config-schema.ts';
@@ -6,6 +6,12 @@ import { resolveBncrChannelPolicy } from '../core/policy.ts';
 import type { BncrRoute } from '../core/types.ts';
 import type { ReplyPayloadInput } from '../messaging/outbound/reply-enqueue.ts';
 import type { OutboundReplyTargetPolicy } from '../messaging/outbound/reply-target-policy.ts';
+import {
+  decodeOpenClawSendBuffer,
+  isOpenClawSendBufferMediaUrl,
+  OPENCLAW_OUTBOUND_MEDIA_MAX_BYTES,
+  saveOpenClawChannelMediaBuffer,
+} from '../openclaw/media-runtime.ts';
 import type { OpenClawChannelToolSend, openClawJsonResult } from '../openclaw/sdk-helpers.ts';
 import { readOpenClawStringParam } from '../openclaw/sdk-helpers.ts';
 import type { BncrBridgeCallBridge } from './bridge-call.ts';
@@ -68,6 +74,7 @@ const BNCR_MESSAGE_TOOL_SCHEMA: BncrMessageToolSchemaContribution = {
 export function createBncrChannelPluginSurfaceGroup(runtime: {
   channelId: string;
   sceneRegistry: Map<string, BncrSceneRecord>;
+  getApi: () => Parameters<typeof saveOpenClawChannelMediaBuffer>[0];
   getMessageSendBridge: () => {
     channelMessageSendText: (
       ctx: Record<string, unknown>,
@@ -222,20 +229,49 @@ export function createBncrChannelPluginSurfaceGroup(runtime: {
       }
 
       const to = readOpenClawStringParam(paramsObj, 'to', { required: true });
-      const toolMediaUrl =
+      const rawBuffer = typeof paramsObj.buffer === 'string' ? paramsObj.buffer : '';
+      const rawMediaUrl =
         (typeof paramsObj.mediaUrl === 'string' ? paramsObj.mediaUrl : '') ||
         (typeof paramsObj.media === 'string' ? paramsObj.media : '') ||
         (typeof paramsObj.path === 'string' ? paramsObj.path : '') ||
         (typeof paramsObj.filePath === 'string' ? paramsObj.filePath : '');
+      const rawMediaUrls = paramsObj.mediaUrls;
+      const declaredMediaUrls = Array.isArray(rawMediaUrls)
+        ? rawMediaUrls.filter((u): u is string => typeof u === 'string')
+        : undefined;
+      const hasExplicitMedia = [rawMediaUrl, ...(declaredMediaUrls ?? [])].some(
+        (mediaUrl) => Boolean(mediaUrl) && !isOpenClawSendBufferMediaUrl(mediaUrl),
+      );
+      let toolMediaUrl = rawMediaUrl;
+      let mediaUrls = declaredMediaUrls;
+      if (rawBuffer && !hasExplicitMedia) {
+        const decoded = decodeOpenClawSendBuffer({
+          buffer: rawBuffer,
+          contentType:
+            typeof paramsObj.contentType === 'string' ? paramsObj.contentType : undefined,
+          mimeType: typeof paramsObj.mimeType === 'string' ? paramsObj.mimeType : undefined,
+          filename: typeof paramsObj.filename === 'string' ? paramsObj.filename : undefined,
+          fileName: typeof paramsObj.fileName === 'string' ? paramsObj.fileName : undefined,
+          maxBytes: OPENCLAW_OUTBOUND_MEDIA_MAX_BYTES,
+        });
+        const saved = await saveOpenClawChannelMediaBuffer(
+          runtime.getApi(),
+          decoded.buffer,
+          decoded.mimeType,
+          'outbound',
+          OPENCLAW_OUTBOUND_MEDIA_MAX_BYTES,
+          decoded.fileName,
+        );
+        toolMediaUrl = saved.path;
+        mediaUrls = declaredMediaUrls?.map((mediaUrl) =>
+          isOpenClawSendBufferMediaUrl(mediaUrl) ? saved.path : mediaUrl,
+        );
+      }
       const rawExtra = paramsObj.extra;
       const extra =
         rawExtra && typeof rawExtra === 'object' && !Array.isArray(rawExtra)
           ? (rawExtra as Record<string, unknown>)
           : undefined;
-      const rawMediaUrls = paramsObj.mediaUrls;
-      const mediaUrls = Array.isArray(rawMediaUrls)
-        ? rawMediaUrls.filter((u): u is string => typeof u === 'string')
-        : undefined;
 
       const toolMessage = readOpenClawStringParam(paramsObj, 'message', { allowEmpty: true }) ?? '';
       const toolCaption = readOpenClawStringParam(paramsObj, 'caption', { allowEmpty: true }) ?? '';

package/src/plugin/inbound-acceptance.ts

@@ -1,4 +1,4 @@
-import { hasControlCommand } from 'openclaw/plugin-sdk/command-auth';
+import { hasControlCommand } from 'openclaw/plugin-sdk/command-detection';
 import { resolveAccount } from '../core/accounts.ts';
 import { checkBncrMessageGate } from '../messaging/inbound/gate.ts';
 import {

package/src/plugin/message-send.ts

@@ -1,4 +1,4 @@
-import type { ChannelMessageSendResult } from 'openclaw/plugin-sdk/channel-message';
+import type { ChannelMessageSendResult } from 'openclaw/plugin-sdk/channel-outbound';
 import type { BncrChannelSendContext } from './channel-runtime-types.ts';
 
 export type BncrMessageSendBridge = {