@xmoxmo/bncr 0.6.4 → 0.6.5

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

@@ -20,7 +20,7 @@ import {
 } from '../../openclaw/routing-runtime.ts';
 import type { BncrInboundApi, BncrInboundConfig, BncrRememberSessionRoute } from './contracts.ts';
 import { INBOUND_MEDIA_URL_MAX_BYTES, isHttpMediaUrl } from './media-url-download.ts';
-import { parseBncrNativeCommand } from './native-command.ts';
+import { parseBncrNativeCommand, resolveBncrNativeCommandParseOptions } from './native-command.ts';
 import { loadInboundRemoteMedia } from './remote-media.ts';
 
 export type ParsedInbound = ReturnType<typeof import('./parse.ts')['parseBncrInboundParams']>;
@@ -460,9 +460,13 @@ export async function prepareBncrInboundDispatch(args: {
   const senderIdForContext = parsed.userId || parsed.clientId || resolution.canonicalTo;
   const senderDisplayName = parsed.userName || resolution.canonicalTo;
   const isBncrNativeCommand =
-    parseBncrNativeCommand(parsed.extracted.text, {
-      allowBareWhoami: parsed.isAdmin !== true,
-    }) !== null;
+    parseBncrNativeCommand(
+      parsed.extracted.text,
+      resolveBncrNativeCommandParseOptions({
+        isAdmin: parsed.isAdmin,
+        peerKind: parsed.peer.kind as 'direct' | 'group',
+      }),
+    ) !== null;
   const isOpenClawNativeCommand =
     !isBncrNativeCommand &&
     hasControlCommand(parsed.extracted.text, cfg as Parameters<typeof hasControlCommand>[1]);

package/src/messaging/inbound/dispatch.ts

@@ -176,6 +176,8 @@ export async function dispatchBncrInbound(params: {
     // A stop command must not wait behind the history serial chain or mutate
     // the accumulated conversation window. Deliver it immediately so the host
     // can abort the active run instead of queuing behind it.
+    const stopOwnerAllowFrom =
+      parsed.peer.kind === 'direct' && senderIdForContext ? [senderIdForContext] : ownerAllowFrom;
     const ctxPayload = await buildBncrInboundTurnContext({
       api,
       cfg,
@@ -185,7 +187,7 @@ export async function dispatchBncrInbound(params: {
       peer,
       senderIdForContext,
       senderDisplayName,
-      ownerAllowFrom,
+      ownerAllowFrom: stopOwnerAllowFrom,
       bridgeSenderId,
       bridgeSenderName,
       historyLimit: resolvedHistoryLimit,

package/src/messaging/inbound/native-command-runtime.ts

@@ -81,6 +81,7 @@ export function createNativeCommandTurnContext(args: {
   peer: ParsedInbound['peer'];
   resolvedRoute: { sessionKey: string; agentId: string; mainSessionKey?: string };
   sessionKey: string;
+  ownerAllowFrom?: string[];
   displayTo: string;
   originatingTo: string;
   senderIdForContext: string;
@@ -167,6 +168,9 @@ export function createNativeCommandTurnContext(args: {
       authorized: true,
       body: args.body,
     };
+    if (args.ownerAllowFrom?.length) {
+      ctx.OwnerAllowFrom = args.ownerAllowFrom;
+    }
     return ctx;
   });
 }

package/src/messaging/inbound/native-command.ts

@@ -50,7 +50,74 @@ export type NativeSessionResetCommand = {
   text: string;
 };
 
-const BNCR_NATIVE_COMMANDS = new Set([
+/**
+ * Commands that non-admin private-chat users may self-elevate for.
+ * When a non-admin direct-chat caller issues one of these commands,
+ * the plugin temporarily treats them as admin so the command follows
+ * the same code path as an admin caller. This whitelist is shared
+ * across permission checks so admin and non-admin logic stay in sync.
+ *
+ * `stop` stays in this whitelist for semantic consistency, but it is
+ * routed through the unified stop fast path in dispatch.ts rather than
+ * the native command handler, so it is never processed here.
+ */
+export const BNCR_SELF_SERVICE_COMMANDS: ReadonlySet<string> = new Set([
+  'whoami',
+  'status',
+  'verbose',
+  'model',
+  'new',
+  'reset',
+  'stop',
+]);
+
+/**
+ * Synthetic command name used when an admin bare command is routed to the
+ * OpenClaw native parser. It must never be exposed to the user.
+ */
+export const BNCR_OPENCLAW_NATIVE_COMMAND = '__openclaw_native__';
+
+/**
+ * Detect if the raw text is a bare whitelist command that should be
+ * elevated to admin for OpenClaw native parsing (private non-admin)
+ * or mapped to /bncr (group non-admin).
+ */
+export function isBncrWhitelistBareCommandText(rawBody: string): string | null {
+  const raw = String(rawBody || '')
+    .trim()
+    .toLowerCase();
+  if (!raw.startsWith('/')) return null;
+  const bare = raw.slice(1);
+  if (!bare) return null;
+  // Whitelist commands match the exact command name only. @bot suffixes are
+  // intentionally unsupported so bare commands stay consistent with /stop.
+  const commandName = bare.split(/\s+/, 1)[0];
+  if (!commandName) return null;
+  return BNCR_SELF_SERVICE_COMMANDS.has(commandName) ? commandName : null;
+}
+
+/**
+ * Resolve which bare slash commands bncr should treat as native commands.
+ *
+ * Admin callers never have whitelist restrictions: their bare commands go to
+ * the OpenClaw parser. Non-admin group callers map the whitelist onto /bncr
+ * native commands; non-admin private callers are elevated and routed to the
+ * OpenClaw parser instead (handled before this helper runs).
+ */
+export function resolveBncrNativeCommandParseOptions(args: {
+  isAdmin: boolean;
+  peerKind: 'direct' | 'group';
+}): ParseBncrNativeCommandOptions {
+  const isGroup = args.peerKind === 'group';
+  const isNonAdmin = args.isAdmin !== true;
+  return {
+    allowBareWhoami: isNonAdmin && isGroup,
+    allowBareStatus: isNonAdmin && isGroup,
+    allowBareSessionReset: isNonAdmin && isGroup,
+  };
+}
+
+export const BNCR_NATIVE_COMMANDS = new Set([
   'help',
   'new',
   'reset',
@@ -128,7 +195,9 @@ export function parseBncrUnsupportedDirectCommand(text: string): {
   const raw = String(text || '').trim();
   if (!raw.startsWith('/')) return null;
 
-  const bareMatch = raw.match(/^\/([A-Za-z0-9_]+)(?:\s+.*)?$/);
+  // Hyphens are allowed in command names (e.g. /history-limit) so bare slash
+  // parsing matches the same command vocabulary as the /bncr subcommands.
+  const bareMatch = raw.match(/^\/([A-Za-z0-9_-]+)(?:\s+.*)?$/);
   if (!bareMatch) return null;
   const bareCommand = String(bareMatch[1] || '')
     .trim()
@@ -158,7 +227,7 @@ const BNCR_HELP_SECTIONS = [
       { label: '/bncr status', scopes: ['admin', 'direct', 'group'] },
       { label: '/bncr new', scopes: ['admin', 'direct'] },
       { label: '/bncr reset', scopes: ['admin', 'direct'] },
-      { label: '/bncr verbose on|off|full', scopes: ['admin'] },
+      { label: '/bncr verbose on|off|full', scopes: ['admin', 'direct'] },
     ],
   },
   {
@@ -180,20 +249,20 @@ const BNCR_HELP_SECTIONS = [
   },
   {
     title: '📋 Conversation history',
-    audience: 'admin',
+    audience: 'all',
     commands: [
-      { label: '/bncr history-help', scopes: ['admin'] },
-      { label: '/bncr history-limit [<number>|clear] [<SceneId>]', scopes: ['admin'] },
-      { label: '/bncr history-force on|off|clear [<SceneId>]', scopes: ['admin'] },
+      { label: '/bncr history-help', scopes: ['admin', 'direct'] },
+      { label: '/bncr history-limit [<number>|clear] [<SceneId>]', scopes: ['admin', 'direct'] },
+      { label: '/bncr history-force on|off|clear [<SceneId>]', scopes: ['admin', 'direct'] },
     ],
   },
   {
     title: '🌐 Remote media',
-    audience: 'admin',
+    audience: 'all',
     commands: [
       {
         label: '/bncr download-media on|off|clear|default on|off [<SceneId>]',
-        scopes: ['admin'],
+        scopes: ['admin', 'direct'],
       },
     ],
   },
@@ -272,26 +341,31 @@ export function resolveBncrNativeSessionResetCommand(args: {
 }): NativeSessionResetCommand | null {
   if (args.command.command !== 'new' && args.command.command !== 'reset') return null;
   const reason = args.command.command === 'new' ? 'new' : 'reset';
-  const scope = args.peerKind === 'group' ? 'this group chat' : 'this private chat';
   return {
     handled: true,
     reason,
-    text:
-      reason === 'new'
-        ? `Started a new session for ${scope}.`
-        : `Reset the current session for ${scope}.`,
+    text: reason === 'new' ? '✅ New session started.' : '✅ Session reset.',
   };
 }
 
 export function resolveBncrNativeVerboseCommand(
   command: NativeCommand,
+  currentLevel?: 'on' | 'off' | 'full',
 ): NativeVerboseCommand | null {
   if (command.command !== 'verbose') return null;
   const rawLevel = String(command.argsText || '')
     .trim()
     .toLowerCase();
   if (!rawLevel || rawLevel === 'status') {
-    return { handled: true, text: 'Current verbose level is unchanged.' };
+    const label =
+      currentLevel === 'full'
+        ? 'full'
+        : currentLevel === 'off'
+          ? 'off'
+          : currentLevel === 'on'
+            ? 'on'
+            : 'default';
+    return { handled: true, text: `Current verbose level: ${label}` };
   }
   if (rawLevel === 'on')
     return { handled: true, verboseLevel: 'on', text: 'Verbose logging enabled.' };

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

@@ -6,6 +6,7 @@ import {
   resolveBncrPinnedMainDmOwnerFromAllowlist,
 } from '../../openclaw/inbound-session-runtime.ts';
 import { dispatchOpenClawReplyWithBufferedBlockDispatcher } from '../../openclaw/reply-runtime.ts';
+import { mergeBncrOwnerAllowFromIntoConfig } from './command-owner.ts';
 import type {
   BncrEnqueueFromReply,
   BncrInboundApi,
@@ -18,7 +19,11 @@ import type {
   ParsedInbound,
 } from './dispatch-prep.ts';
 import { buildBncrInboundRecordUpdateLastRoute } from './last-route.ts';
-import { isBncrStopCommandText, parseBncrNativeCommand } from './native-command.ts';
+import {
+  isBncrStopCommandText,
+  parseBncrNativeCommand,
+  resolveBncrNativeCommandParseOptions,
+} from './native-command.ts';
 import { buildBncrReplyConfig } from './reply-config.ts';
 import { runBncrReplyDispatchSerial } from './reply-dispatch-serial.ts';
 import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
@@ -29,32 +34,6 @@ import {
 } from './session-label.ts';
 import { createBncrSessionMetaTaskBarrier } from './session-meta-task.ts';
 
-function mergeBncrCommandOwnerAllowFrom(args: {
-  cfg: BncrInboundConfig;
-  parsed: ParsedInbound;
-  isBncrNativeCommand: boolean;
-  senderIdForContext: string;
-}) {
-  const { cfg, parsed, isBncrNativeCommand, senderIdForContext } = args;
-  if (parsed.isAdmin !== true || isBncrNativeCommand) return cfg;
-  const senderId = String(senderIdForContext || '').trim();
-  if (!senderId) return cfg;
-
-  const currentCommands = (cfg.commands || {}) as { ownerAllowFrom?: string[] };
-  const currentOwnerAllowFrom = Array.isArray(currentCommands.ownerAllowFrom)
-    ? currentCommands.ownerAllowFrom
-    : [];
-  if (currentOwnerAllowFrom.includes(senderId)) return cfg;
-
-  return {
-    ...cfg,
-    commands: {
-      ...currentCommands,
-      ownerAllowFrom: [...currentOwnerAllowFrom, senderId],
-    },
-  } satisfies BncrInboundConfig;
-}
-
 function sleep(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -180,15 +159,17 @@ export async function runBncrInboundReplyDispatch(args: {
     pinnedMainDmOwner,
   });
   const isBncrNativeCommand =
-    parseBncrNativeCommand(rawBody, {
-      allowBareWhoami: parsed.isAdmin !== true,
-    }) !== null;
-  const commandDispatchCfg = mergeBncrCommandOwnerAllowFrom({
-    cfg,
-    parsed,
-    isBncrNativeCommand,
-    senderIdForContext,
-  });
+    parseBncrNativeCommand(
+      rawBody,
+      resolveBncrNativeCommandParseOptions({
+        isAdmin: parsed.isAdmin,
+        peerKind: parsed.peer.kind as 'direct' | 'group',
+      }),
+    ) !== null;
+  const commandDispatchCfg =
+    parsed.isAdmin === true && !isBncrNativeCommand
+      ? mergeBncrOwnerAllowFromIntoConfig({ cfg, senderIdForContext })
+      : cfg;
 
   if (!shouldDispatch) {
     await wrapBncrInboundRecordSessionLabelCorrection({

package/src/messaging/inbound/scene-admin.ts

@@ -435,13 +435,41 @@ export function executeSceneAdminCommand(args: {
   defaultAdminAgentId: string;
   defaultPublicAgentId: string;
   now: () => number;
+  /**
+   * When true, non-admin callers in direct chat are allowed to execute
+   * self-admin commands (history-*, download-media) scoped to
+   * their own session only.  The flag is set by the caller after an
+   * explicit allow-list check – it must NOT be granted unconditionally
+   * for direct chat.
+   */
+  allowNonAdminSelfAdmin?: boolean;
 }): { ok: true; text: string } | { ok: false; text: string } {
-  const { parsed, command, sceneRegistry, defaultAdminAgentId, defaultPublicAgentId, now } = args;
-
-  if (!parsed.isAdmin) {
+  const {
+    parsed,
+    command,
+    sceneRegistry,
+    defaultAdminAgentId,
+    defaultPublicAgentId,
+    now,
+    allowNonAdminSelfAdmin,
+  } = args;
+
+  // Admin always passes; non-admin only passes when the caller explicitly
+  // opted in via allowNonAdminSelfAdmin (self-admin commands in direct chat).
+  if (!parsed.isAdmin && !allowNonAdminSelfAdmin) {
     return { ok: false, text: 'Admin permission required.' };
   }
 
+  // Non-admin self-admin: enforce that sceneId targets only the caller's own session.
+  if (allowNonAdminSelfAdmin && !parsed.isAdmin) {
+    const currentSceneKey = resolveCurrentSceneKey(parsed);
+    const cmdSceneKey =
+      'sceneKey' in command ? (command as { sceneKey?: string }).sceneKey : undefined;
+    if (cmdSceneKey && currentSceneKey && cmdSceneKey !== currentSceneKey) {
+      return { ok: false, text: 'You can only manage your own private chat session.' };
+    }
+  }
+
   if (command.kind === 'history-help') {
     return { ok: true, text: HISTORY_HELP_TEXT };
   }

package/src/openclaw/inbound-session-runtime.ts

@@ -1,6 +1,7 @@
 import { recordInboundSession as sdkRecordInboundSession } from 'openclaw/plugin-sdk/conversation-runtime';
 import { resolvePinnedMainDmOwnerFromAllowlist as sdkResolvePinnedMainDmOwnerFromAllowlist } from 'openclaw/plugin-sdk/security-runtime';
 import {
+  getSessionEntry as sdkGetSessionEntry,
   recordSessionMetaFromInbound as sdkRecordSessionMetaFromInbound,
   resolveStorePath as sdkResolveStorePath,
   updateSessionStoreEntry as sdkUpdateSessionStoreEntry,
@@ -14,6 +15,7 @@ type ResolveStorePathFn = (
 type RecordInboundSessionFn = typeof sdkRecordInboundSession;
 type RecordSessionMetaFromInboundFn = typeof sdkRecordSessionMetaFromInbound;
 type UpdateSessionStoreEntryFn = typeof sdkUpdateSessionStoreEntry;
+type GetSessionEntryFn = typeof sdkGetSessionEntry;
 type ReadSessionUpdatedAtFn = (params: { storePath: string; sessionKey: string }) => unknown;
 type ResolvePinnedMainDmOwnerFromAllowlistFn = typeof sdkResolvePinnedMainDmOwnerFromAllowlist;
 
@@ -22,6 +24,7 @@ type BncrInboundSessionRuntime = {
   recordInboundSession: RecordInboundSessionFn;
   recordSessionMetaFromInbound: RecordSessionMetaFromInboundFn;
   updateSessionStoreEntry: UpdateSessionStoreEntryFn;
+  getSessionEntry: GetSessionEntryFn;
   readSessionUpdatedAt?: ReadSessionUpdatedAtFn;
   resolvePinnedMainDmOwnerFromAllowlist: ResolvePinnedMainDmOwnerFromAllowlistFn;
 };
@@ -36,6 +39,7 @@ function resolveRuntime(): BncrInboundSessionRuntime {
       testRuntimeOverride?.recordSessionMetaFromInbound ?? sdkRecordSessionMetaFromInbound,
     updateSessionStoreEntry:
       testRuntimeOverride?.updateSessionStoreEntry ?? sdkUpdateSessionStoreEntry,
+    getSessionEntry: testRuntimeOverride?.getSessionEntry ?? sdkGetSessionEntry,
     readSessionUpdatedAt: testRuntimeOverride?.readSessionUpdatedAt,
     resolvePinnedMainDmOwnerFromAllowlist:
       testRuntimeOverride?.resolvePinnedMainDmOwnerFromAllowlist ??
@@ -81,6 +85,19 @@ export function readBncrSessionUpdatedAt(
   return readSessionUpdatedAt(params);
 }
 
+export async function readBncrSessionEntry(params: {
+  storePath: string;
+  sessionKey: string;
+}): Promise<Record<string, unknown> | undefined> {
+  const runtime = resolveRuntime();
+  try {
+    const entry = await runtime.getSessionEntry(params);
+    return entry && typeof entry === 'object' ? (entry as Record<string, unknown>) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 export function resolveBncrPinnedMainDmOwnerFromAllowlist(
   params: Parameters<ResolvePinnedMainDmOwnerFromAllowlistFn>[0],
 ): ReturnType<ResolvePinnedMainDmOwnerFromAllowlistFn> {

package/src/openclaw/session-reset-runtime.ts

@@ -0,0 +1,77 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+type SessionResetResult = { ok?: boolean } | undefined;
+type SessionResetParams = {
+  key: string;
+  reason: 'new' | 'reset';
+  agentId?: string;
+  commandSource?: string;
+};
+type SessionResetFn = (params: SessionResetParams) => Promise<SessionResetResult>;
+
+let testOverride: SessionResetFn | null = null;
+let resolvedSessionRuntimeUrlCache: string | null = null;
+
+export function setBncrSessionResetRuntimeForTest(fn: SessionResetFn | null): () => void {
+  const previous = testOverride;
+  testOverride = fn;
+  return () => {
+    testOverride = previous;
+  };
+}
+
+function resolveOpenClawSessionsRuntimeUrl(): string {
+  if (resolvedSessionRuntimeUrlCache) return resolvedSessionRuntimeUrlCache;
+  let current = dirname(fileURLToPath(import.meta.url));
+  let pluginRoot: string | null = null;
+  while (true) {
+    const pkgPath = join(current, 'package.json');
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as { name?: string };
+      if (pkg.name === '@xmoxmo/bncr') {
+        pluginRoot = current;
+        break;
+      }
+    } catch {
+      // Keep walking up toward the plugin root.
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  if (!pluginRoot) {
+    throw new Error('bncr plugin root not found for session reset runtime');
+  }
+
+  // Try candidate paths for the sessions runtime re-export file.
+  // The hash-stamped bundle name may change across OpenClaw releases, so we
+  // first try the stable re-export entry and fall back to the known hash.
+  const candidates = [
+    join(pluginRoot, 'node_modules', 'openclaw', 'dist', 'sessions.runtime.js'),
+    join(pluginRoot, 'node_modules', 'openclaw', 'dist', 'sessions.runtime-BQwwkuFq.js'),
+  ];
+  for (const target of candidates) {
+    if (existsSync(target)) {
+      resolvedSessionRuntimeUrlCache = pathToFileURL(target).href;
+      return resolvedSessionRuntimeUrlCache;
+    }
+  }
+  throw new Error(
+    `OpenClaw sessions runtime not found under ${join(pluginRoot, 'node_modules', 'openclaw', 'dist')}`,
+  );
+}
+
+export async function performBncrGatewaySessionReset(
+  params: SessionResetParams,
+): Promise<SessionResetResult> {
+  if (testOverride) return testOverride(params);
+  const mod = (await import(resolveOpenClawSessionsRuntimeUrl())) as {
+    performGatewaySessionReset?: SessionResetFn;
+  };
+  if (typeof mod.performGatewaySessionReset !== 'function') {
+    throw new Error('OpenClaw performGatewaySessionReset is unavailable');
+  }
+  return mod.performGatewaySessionReset(params);
+}

package/src/plugin/inbound-acceptance.ts

@@ -1,7 +1,10 @@
 import { hasControlCommand } from 'openclaw/plugin-sdk/command-auth';
 import { resolveAccount } from '../core/accounts.ts';
 import { checkBncrMessageGate } from '../messaging/inbound/gate.ts';
-import { parseBncrNativeCommand } from '../messaging/inbound/native-command.ts';
+import {
+  parseBncrNativeCommand,
+  resolveBncrNativeCommandParseOptions,
+} from '../messaging/inbound/native-command.ts';
 import type { parseBncrInboundParams } from '../messaging/inbound/parse.ts';
 import type { OpenClawResolvedAgentRoute } from '../openclaw/routing-runtime.ts';
 import type { buildInboundResponsePayload } from './channel-inbound-helpers.ts';
@@ -21,9 +24,13 @@ function resolveDispatchBy(args: {
   if (!admission.allowed) return 'denied';
 
   const isBncrNativeCommand =
-    parseBncrNativeCommand(parsed.extracted.text, {
-      allowBareWhoami: parsed.isAdmin !== true,
-    }) !== null;
+    parseBncrNativeCommand(
+      parsed.extracted.text,
+      resolveBncrNativeCommandParseOptions({
+        isAdmin: parsed.isAdmin,
+        peerKind: parsed.peer.kind as 'direct' | 'group',
+      }),
+    ) !== null;
   const isAdminOpenClawNativeCommand =
     parsed.isAdmin === true &&
     !isBncrNativeCommand &&
@@ -49,9 +56,13 @@ function shouldDispatchForScene(args: {
   if (!admission.allowed) return false;
 
   const isBncrNativeCommand =
-    parseBncrNativeCommand(parsed.extracted.text, {
-      allowBareWhoami: parsed.isAdmin !== true,
-    }) !== null;
+    parseBncrNativeCommand(
+      parsed.extracted.text,
+      resolveBncrNativeCommandParseOptions({
+        isAdmin: parsed.isAdmin,
+        peerKind: parsed.peer.kind as 'direct' | 'group',
+      }),
+    ) !== null;
   const isAdminOpenClawNativeCommand =
     parsed.isAdmin === true &&
     !isBncrNativeCommand &&