@xmoxmo/bncr 0.4.3 → 0.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmoxmo/bncr",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "private": false,
   "type": "module",
   "license": "MIT",

package/scripts/selfcheck.mjs

@@ -1,3 +1,4 @@
+import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
@@ -182,6 +183,19 @@ const readPackageVersion = () => {
   return typeof pkg?.version === 'string' ? pkg.version.trim() : '';
 };
 
+const readNpmLatestVersion = (packageName) => {
+  try {
+    const raw = execFileSync('npm', ['view', packageName, 'version'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 10000,
+    }).trim();
+    return raw || null;
+  } catch {
+    return null;
+  }
+};
+
 const requiredOpenClawSdkSubpaths = [
   'openclaw/plugin-sdk',
   'openclaw/plugin-sdk/boolean-param',
@@ -213,7 +227,7 @@ const resolveOpenClawSdkSubpaths = () => {
   });
 };
 
-const validateVersionPolicy = (version) => {
+const validateVersionPolicy = (version, latestVersion) => {
   const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
   if (!match) {
     return {
@@ -232,12 +246,101 @@ const validateVersionPolicy = (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 versionPolicy = validateVersionPolicy(version);
+const packageName = '@xmoxmo/bncr';
+const latestVersion = readNpmLatestVersion(packageName);
+const versionPolicy = validateVersionPolicy(version, latestVersion);
 const sdkSubpaths = resolveOpenClawSdkSubpaths();
 const missingSdkSubpaths = sdkSubpaths.filter((entry) => !entry.ok);
 const result = {

package/src/channel.ts

@@ -1727,6 +1727,10 @@ class BncrBridgeRuntime {
     handleFileTransferPushFailure: (args) => this.handleFileTransferPushFailure(args),
     handleTextPushFailure: (args) => this.handleTextPushFailure(args),
     isPrePushGuardDeferral: (entry) => this.isPrePushGuardDeferral(entry),
+    resolveAccountIdForSession: (sessionKey) => {
+      const hit = this.sessionRoutes.get(sessionKey);
+      return hit ? hit.accountId : BNCR_DEFAULT_ACCOUNT_ID;
+    },
     scheduleSave: () => this.scheduleSave(),
     logInfo: (scope, message, options) => this.logInfo(scope, message, options),
     logWarn: (scope, message, options) => this.logWarn(scope, message, options),

package/src/openclaw/media-runtime.ts

@@ -1,3 +1,6 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
 type RuntimeMediaLoaded = {
   buffer: Buffer;
   contentType?: string;
@@ -40,6 +43,23 @@ export function isOpenClawRemoteHttpMediaUrl(mediaUrl: string): boolean {
   return /^https?:\/\//i.test(String(mediaUrl || '').trim());
 }
 
+/**
+ * Try to resolve a relative media path against each local root.
+ * Returns the first absolute path that exists on disk, or the original
+ * relative path if nothing is found (the host will then emit its own error).
+ */
+export function resolveRelativeMediaPath(mediaUrl: string, localRoots?: readonly string[]): string {
+  if (!mediaUrl || !localRoots?.length) return mediaUrl;
+  if (path.isAbsolute(mediaUrl)) return mediaUrl;
+  // HTTP / file:// / data: / ~ paths are handled elsewhere
+  if (/^(https?|file|data):/i.test(mediaUrl) || mediaUrl.startsWith('~')) return mediaUrl;
+  for (const root of localRoots) {
+    const candidate = path.resolve(root, mediaUrl);
+    if (existsSync(candidate)) return candidate;
+  }
+  return mediaUrl;
+}
+
 export async function loadOpenClawWebMedia(
   api: RuntimeApiHolder,
   mediaUrl: string,
@@ -54,7 +74,11 @@ export async function loadOpenClawWebMedia(
   if (typeof loadWebMedia !== 'function') {
     throw new Error('OpenClaw runtime media loadWebMedia API is unavailable');
   }
-  return loadWebMedia(mediaUrl, options);
+
+  // Resolve relative paths against local roots before handing off to the host
+  const resolvedUrl = resolveRelativeMediaPath(mediaUrl, options?.localRoots);
+
+  return loadWebMedia(resolvedUrl, options);
 }
 
 export async function saveOpenClawChannelMediaBuffer(

package/src/plugin/ack-outbox-runtime-group.ts

@@ -19,6 +19,7 @@ export function createBncrAckOutboxRuntimeGroup(runtime: {
   isPlainObject: (value: unknown) => value is Record<string, unknown>;
   clampFiniteNumber: (value: unknown, fallback: number, min?: number, max?: number) => number;
   normalizeAccountId: (accountId: string) => string;
+  resolveAccountIdForSession: (sessionKey: string) => string | null;
   formatDisplayScope: (route: OutboxEntry['route']) => string;
   isFileTransferEntry: (entry: OutboxEntry) => boolean;
   recommendedAckTimeoutMaxMs: number;
@@ -235,6 +236,7 @@ export function createBncrAckOutboxRuntimeGroup(runtime: {
     handleFileTransferPushFailure: runtime.handleFileTransferPushFailure,
     handleTextPushFailure: runtime.handleTextPushFailure,
     isPrePushGuardDeferral: runtime.isPrePushGuardDeferral,
+    resolveAccountIdForSession: runtime.resolveAccountIdForSession,
     moveToDeadLetter: runtime.moveToDeadLetter,
     scheduleSave: runtime.scheduleSave,
     logInfo: runtime.logInfo,

package/src/plugin/outbox-drain-failure.ts

@@ -20,6 +20,9 @@ type BncrOutboxDrainScheduleRuntime = {
 type BncrOutboxDrainFailureRuntime = {
   backoffMs: (retryCount: number) => number;
   outbox: Map<string, OutboxEntry>;
+  resolveAccountIdForSession: (sessionKey: string) => string | null;
+  logInfo: (scope: string, message: string, options?: { debugOnly?: boolean }) => void;
+  logWarn: (scope: string, message: string, options?: { debugOnly?: boolean }) => void;
   isPrePushGuardDeferral: (entry: OutboxEntry) => boolean;
   moveToDeadLetter: (entry: OutboxEntry, reason: string) => void;
   scheduleSave: () => void;
@@ -39,6 +42,39 @@ export function createBncrOutboxDrainFailure(runtime: BncrOutboxDrainFailureRunt
     const { accountId, entry, attemptedAt, updateMinOutboxDelay } = args;
     let { localNextDelay } = args;
 
+    // If the entry keeps hitting pre-push guard (no active connection), the
+    // accountId on the entry might be wrong (e.g. constructed from route data).
+    // Try to correct it from recent inbound session context before giving up.
+    if (runtime.isPrePushGuardDeferral(entry) && entry.retryCount > 0) {
+      const corrected = runtime.resolveAccountIdForSession(entry.sessionKey);
+      if (corrected && corrected !== entry.accountId) {
+        const oldAccountId = entry.accountId;
+        runtime.logWarn(
+          'outbound',
+          `account corrected sessionKey=${entry.sessionKey} ${oldAccountId}→${corrected}`,
+        );
+        runtime.logInfo(
+          'outbound',
+          JSON.stringify({
+            event: 'account-corrected',
+            messageId: entry.messageId,
+            sessionKey: entry.sessionKey,
+            oldAccountId,
+            corrected,
+            retryCount: entry.retryCount,
+            lastError: entry.lastError,
+          }),
+          { debugOnly: true },
+        );
+        entry.accountId = corrected;
+        entry.retryCount = 0;
+        entry.lastError = undefined;
+        runtime.outbox.set(entry.messageId, entry);
+        runtime.scheduleSave();
+        return { action: 'continue', localNextDelay };
+      }
+    }
+
     if (runtime.isPrePushGuardDeferral(entry)) {
       const wait = runtime.prePushGuardRetryDelayMs;
       localNextDelay = runtime.outboxDrainSchedule.scheduleAccountWait({

package/src/plugin/outbox-drain-runtime.ts

@@ -58,6 +58,7 @@ type BncrOutboxDrainRuntime = {
   backoffMs: (retryCount: number) => number;
   isPlainObject: (value: unknown) => value is Record<string, unknown>;
   normalizeAccountId: (accountId: string) => string;
+  resolveAccountIdForSession: (sessionKey: string) => string | null;
   stopped: () => boolean;
   outbox: Map<string, OutboxEntry>;
   deadLetter: () => OutboxEntry[];
@@ -132,7 +133,19 @@ type BncrOutboxDrainRuntime = {
 
 export function createBncrOutboxDrainRuntime(runtime: BncrOutboxDrainRuntime) {
   const handlePushedDrainEntry = createBncrOutboxDrainPostPush(runtime);
-  const handleFailedDrainEntry = createBncrOutboxDrainFailure(runtime);
+  const handleFailedDrainEntry = createBncrOutboxDrainFailure({
+    backoffMs: runtime.backoffMs,
+    outbox: runtime.outbox,
+    resolveAccountIdForSession: runtime.resolveAccountIdForSession,
+    logInfo: runtime.logInfo,
+    logWarn: runtime.logWarn,
+    isPrePushGuardDeferral: runtime.isPrePushGuardDeferral,
+    moveToDeadLetter: runtime.moveToDeadLetter,
+    scheduleSave: runtime.scheduleSave,
+    outboxDrainSchedule: runtime.outboxDrainSchedule,
+    maxRetry: runtime.maxRetry,
+    prePushGuardRetryDelayMs: runtime.prePushGuardRetryDelayMs,
+  });
 
   return createBncrOutboxDrainLoop(runtime, {
     handlePushedDrainEntry,

package/src/plugin/target-runtime.ts

@@ -133,9 +133,17 @@ export function createBncrTargetRuntime(runtime: {
     return verified;
   }
 
+  function resolveSessionAccountId(sessionKey: string): string | null {
+    const key = asString(sessionKey).trim();
+    if (!key) return null;
+    const hit = runtime.sessionRoutes.get(key);
+    return hit ? hit.accountId : null;
+  }
+
   return {
     rememberSessionRoute,
     resolveRouteBySession,
     resolveVerifiedTarget,
+    resolveSessionAccountId,
   };
 }