@xmoxmo/bncr 0.3.6 → 0.3.7

package/src/plugin/file-inbound-chunk.ts

@@ -0,0 +1,146 @@
+import { createHash } from 'node:crypto';
+import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import { getErrorMessage } from './error-message.ts';
+import type { BncrFileInboundRuntime } from './file-inbound-runtime.ts';
+import {
+  isAbortedInboundTransfer,
+  isActiveInboundTransfer,
+  isCompletedInboundTransfer,
+  markInboundTransferTransferring,
+} from './file-inbound-state.ts';
+import { buildBncrGatewayEventContext } from './gateway-event-context.ts';
+
+export function createBncrFileInboundChunkHandler(runtime: BncrFileInboundRuntime) {
+  return async function handleFileChunk({
+    params,
+    respond,
+    client,
+    context,
+  }: GatewayRequestHandlerOptions) {
+    const gatewayContext = buildBncrGatewayEventContext({
+      params,
+      client,
+      context,
+      asString: runtime.asString,
+      normalizeAccountId: runtime.normalizeAccountId,
+      now: runtime.now,
+    });
+    const { accountId, connId, clientId } = gatewayContext;
+
+    const transferId = runtime.asString(params?.transferId || '').trim();
+    const chunkIndex = runtime.finiteNonNegativeNumberOrNull(params?.chunkIndex);
+    const offset = runtime.finiteNonNegativeNumberOrNull(params?.offset ?? 0);
+    const size = runtime.finiteNonNegativeNumberOrNull(params?.size ?? 0);
+    const chunkSha256 = runtime.asString(params?.chunkSha256 || '').trim();
+    const base64 = runtime.asString(params?.base64 || '');
+
+    if (!transferId || chunkIndex == null || !base64) {
+      respond(false, { error: 'transferId/chunkIndex/base64 required' });
+      return;
+    }
+
+    const st = runtime.fileRecvTransfers.get(transferId);
+    if (!st) {
+      respond(false, { error: 'transfer not found' });
+      return;
+    }
+    if (isCompletedInboundTransfer(st)) {
+      respond(true, {
+        ok: true,
+        transferId,
+        status: 'completed',
+        path: st.completedPath,
+        ignored: true,
+        terminal: true,
+      });
+      return;
+    }
+    if (isAbortedInboundTransfer(st)) {
+      respond(true, {
+        ok: true,
+        transferId,
+        status: 'aborted',
+        error: st.error,
+        ignored: true,
+        terminal: true,
+      });
+      return;
+    }
+    if (!isActiveInboundTransfer(st)) {
+      respond(false, { error: 'transfer not active' });
+      return;
+    }
+    if (chunkIndex >= st.totalChunks) {
+      respond(false, {
+        error: `chunkIndex out of range index=${chunkIndex} total=${st.totalChunks}`,
+      });
+      return;
+    }
+
+    const staleObserved = runtime.observeLease('file.chunk', params ?? {});
+    if (staleObserved.stale) {
+      if (
+        !runtime.matchesTransferOwner({
+          ownerConnId: st.ownerConnId,
+          ownerClientId: st.ownerClientId,
+          connId,
+          clientId,
+        })
+      ) {
+        runtime.logWarn(
+          'stale',
+          `ignore kind=file.chunk accountId=${accountId} connId=${connId} clientId=${clientId || '-'} transferId=${transferId} reason=owner-mismatch ownerConnId=${st.ownerConnId || '-'} ownerClientId=${st.ownerClientId || '-'}`,
+          { debugOnly: true },
+        );
+        respond(true, { ok: true, stale: true, ignored: true });
+        return;
+      }
+    } else {
+      runtime.refreshAcceptedFileTransferLiveState({
+        accountId,
+        connId,
+        clientId,
+        context: gatewayContext.context,
+      });
+    }
+
+    try {
+      const buf = Buffer.from(base64, 'base64');
+      if (size != null && size > 0 && buf.length !== size) {
+        throw new Error(`chunk size mismatch expected=${size} got=${buf.length}`);
+      }
+      if (chunkSha256) {
+        const digest = createHash('sha256').update(buf).digest('hex');
+        if (digest !== chunkSha256) throw new Error('chunk sha256 mismatch');
+      }
+      st.bufferByChunk.set(chunkIndex, buf);
+      st.receivedChunks.add(chunkIndex);
+      runtime.fileRecvTransfers.set(transferId, markInboundTransferTransferring(st));
+
+      respond(
+        true,
+        staleObserved.stale
+          ? {
+              ok: true,
+              transferId,
+              chunkIndex,
+              offset,
+              received: st.receivedChunks.size,
+              totalChunks: st.totalChunks,
+              stale: true,
+              staleAccepted: true,
+            }
+          : {
+              ok: true,
+              transferId,
+              chunkIndex,
+              offset,
+              received: st.receivedChunks.size,
+              totalChunks: st.totalChunks,
+            },
+      );
+    } catch (error) {
+      respond(false, { error: getErrorMessage(error, 'chunk invalid') });
+    }
+  };
+}

package/src/plugin/file-inbound-complete.ts

@@ -0,0 +1,153 @@
+import { createHash } from 'node:crypto';
+import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import { getErrorMessage } from './error-message.ts';
+import type { BncrFileInboundRuntime } from './file-inbound-runtime.ts';
+import {
+  type BncrInboundFileChunkEntry,
+  isAbortedInboundTransfer,
+  isCompletedInboundTransfer,
+  markInboundTransferAborted,
+  markInboundTransferCompleted,
+} from './file-inbound-state.ts';
+import { buildBncrGatewayEventContext } from './gateway-event-context.ts';
+
+export function createBncrFileInboundCompleteHandler(runtime: BncrFileInboundRuntime) {
+  return async function handleFileComplete({
+    params,
+    respond,
+    client,
+    context,
+  }: GatewayRequestHandlerOptions) {
+    const gatewayContext = buildBncrGatewayEventContext({
+      params,
+      client,
+      context,
+      asString: runtime.asString,
+      normalizeAccountId: runtime.normalizeAccountId,
+      now: runtime.now,
+    });
+    const { accountId, connId, clientId } = gatewayContext;
+
+    const transferId = runtime.asString(params?.transferId || '').trim();
+    if (!transferId) {
+      respond(false, { error: 'transferId required' });
+      return;
+    }
+
+    const st = runtime.fileRecvTransfers.get(transferId);
+    if (!st) {
+      respond(false, { error: 'transfer not found' });
+      return;
+    }
+    if (isCompletedInboundTransfer(st)) {
+      respond(true, {
+        ok: true,
+        transferId,
+        status: 'completed',
+        path: st.completedPath,
+        ignored: true,
+        terminal: true,
+      });
+      return;
+    }
+    if (isAbortedInboundTransfer(st)) {
+      respond(true, {
+        ok: true,
+        transferId,
+        status: 'aborted',
+        error: st.error,
+        ignored: true,
+        terminal: true,
+      });
+      return;
+    }
+
+    const staleObserved = runtime.observeLease('file.complete', params ?? {});
+    if (staleObserved.stale) {
+      if (
+        !runtime.matchesTransferOwner({
+          ownerConnId: st.ownerConnId,
+          ownerClientId: st.ownerClientId,
+          connId,
+          clientId,
+        })
+      ) {
+        runtime.logWarn(
+          'stale',
+          `ignore kind=file.complete accountId=${accountId} connId=${connId} clientId=${clientId || '-'} transferId=${transferId} reason=owner-mismatch ownerConnId=${st.ownerConnId || '-'} ownerClientId=${st.ownerClientId || '-'}`,
+          { debugOnly: true },
+        );
+        respond(true, { ok: true, stale: true, ignored: true });
+        return;
+      }
+    } else {
+      runtime.refreshAcceptedFileTransferLiveState({
+        accountId,
+        connId,
+        clientId,
+        context: gatewayContext.context,
+      });
+    }
+
+    try {
+      if (st.receivedChunks.size < st.totalChunks) {
+        throw new Error(
+          `chunk not complete received=${st.receivedChunks.size} total=${st.totalChunks}`,
+        );
+      }
+
+      const ordered = (Array.from(st.bufferByChunk.entries()) as BncrInboundFileChunkEntry[])
+        .sort((a, b) => a[0] - b[0])
+        .map((x) => x[1]);
+      const merged = Buffer.concat(ordered);
+      if (st.fileSize > 0 && merged.length !== st.fileSize) {
+        throw new Error(`file size mismatch expected=${st.fileSize} got=${merged.length}`);
+      }
+      const digest = createHash('sha256').update(merged).digest('hex');
+      if (st.fileSha256 && digest !== st.fileSha256) {
+        throw new Error('file sha256 mismatch');
+      }
+
+      const saved = await runtime.saveInboundMediaBuffer({
+        buffer: merged,
+        mimeType: st.mimeType,
+        fileName: st.fileName,
+      });
+      const completedState = markInboundTransferCompleted(st, saved.path, runtime.now());
+      runtime.fileRecvTransfers.set(transferId, completedState);
+
+      respond(
+        true,
+        staleObserved.stale
+          ? {
+              ok: true,
+              transferId,
+              path: saved.path,
+              size: merged.length,
+              fileName: st.fileName,
+              mimeType: st.mimeType,
+              fileSha256: digest,
+              stale: true,
+              staleAccepted: true,
+            }
+          : {
+              ok: true,
+              transferId,
+              path: saved.path,
+              size: merged.length,
+              fileName: st.fileName,
+              mimeType: st.mimeType,
+              fileSha256: digest,
+            },
+      );
+    } catch (error) {
+      const abortedState = markInboundTransferAborted(
+        st,
+        getErrorMessage(error, 'complete failed'),
+        runtime.now(),
+      );
+      runtime.fileRecvTransfers.set(transferId, abortedState);
+      respond(false, { error: abortedState.error });
+    }
+  };
+}

package/src/plugin/file-inbound-handlers.ts

@@ -0,0 +1,19 @@
+import { createBncrFileInboundAbortHandler } from './file-inbound-abort.ts';
+import { createBncrFileInboundChunkHandler } from './file-inbound-chunk.ts';
+import { createBncrFileInboundCompleteHandler } from './file-inbound-complete.ts';
+import { createBncrFileInboundInitHandler } from './file-inbound-init.ts';
+import type { BncrFileInboundRuntime } from './file-inbound-runtime.ts';
+
+export function createBncrFileInboundHandlers(runtime: BncrFileInboundRuntime) {
+  const handleFileInit = createBncrFileInboundInitHandler(runtime);
+  const handleFileChunk = createBncrFileInboundChunkHandler(runtime);
+  const handleFileComplete = createBncrFileInboundCompleteHandler(runtime);
+  const handleFileAbort = createBncrFileInboundAbortHandler(runtime);
+
+  return {
+    handleFileInit,
+    handleFileChunk,
+    handleFileComplete,
+    handleFileAbort,
+  };
+}

package/src/plugin/file-inbound-init.ts

@@ -0,0 +1,122 @@
+import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import type { BncrFileInboundRuntime } from './file-inbound-runtime.ts';
+import { buildBncrGatewayEventContext } from './gateway-event-context.ts';
+
+export function createBncrFileInboundInitHandler(runtime: BncrFileInboundRuntime) {
+  return async function handleFileInit({
+    params,
+    respond,
+    client,
+    context,
+  }: GatewayRequestHandlerOptions) {
+    const gatewayContext = buildBncrGatewayEventContext({
+      params,
+      client,
+      context,
+      asString: runtime.asString,
+      normalizeAccountId: runtime.normalizeAccountId,
+      now: runtime.now,
+    });
+    const { accountId, connId, clientId } = gatewayContext;
+    if (
+      runtime.shouldIgnoreStaleEvent({
+        kind: 'file.init',
+        payload: params ?? {},
+        accountId,
+        connId,
+        clientId,
+      })
+    ) {
+      respond(true, { ok: true, stale: true, ignored: true });
+      return;
+    }
+    runtime.refreshAcceptedFileTransferLiveState({
+      accountId,
+      connId,
+      clientId,
+      context: gatewayContext.context,
+    });
+
+    const transferId = runtime.asString(params?.transferId || '').trim();
+    const sessionKey = runtime.asString(params?.sessionKey || '').trim();
+    const fileName = runtime.asString(params?.fileName || '').trim() || 'file.bin';
+    const mimeType = runtime.asString(params?.mimeType || '').trim() || 'application/octet-stream';
+    const fileSize = runtime.finiteNonNegativeNumberOrNull(params?.fileSize);
+    const chunkSize = runtime.finiteNonNegativeNumberOrNull(params?.chunkSize ?? 256 * 1024);
+    const totalChunks = runtime.finiteNonNegativeNumberOrNull(params?.totalChunks);
+    const fileSha256 = runtime.asString(params?.fileSha256 || '').trim();
+
+    if (!transferId || !sessionKey || !fileSize || !chunkSize || !totalChunks) {
+      respond(false, { error: 'transferId/sessionKey/fileSize/chunkSize/totalChunks required' });
+      return;
+    }
+    if (fileSize > runtime.inboundFileTransferMaxBytes) {
+      respond(false, {
+        error: `fileSize too large size=${fileSize} max=${runtime.inboundFileTransferMaxBytes}`,
+      });
+      return;
+    }
+    if (totalChunks > runtime.inboundFileTransferMaxChunks) {
+      respond(false, {
+        error: `totalChunks too large total=${totalChunks} max=${runtime.inboundFileTransferMaxChunks}`,
+      });
+      return;
+    }
+    const expectedTotalChunks = Math.ceil(fileSize / chunkSize);
+    if (totalChunks !== expectedTotalChunks) {
+      respond(false, {
+        error: `totalChunks mismatch total=${totalChunks} expected=${expectedTotalChunks}`,
+      });
+      return;
+    }
+
+    const normalized = runtime.normalizeStoredSessionKey(sessionKey);
+    if (!normalized) {
+      respond(false, { error: 'invalid sessionKey' });
+      return;
+    }
+
+    const existing = runtime.fileRecvTransfers.get(transferId);
+    if (existing) {
+      respond(true, {
+        ok: true,
+        transferId,
+        status: existing.status,
+        duplicated: true,
+      });
+      return;
+    }
+
+    const route =
+      runtime.parseRouteLike({
+        platform: runtime.asString(params?.platform || normalized.route.platform),
+        groupId: runtime.asString(params?.groupId || normalized.route.groupId),
+        userId: runtime.asString(params?.userId || normalized.route.userId),
+      }) || normalized.route;
+
+    runtime.fileRecvTransfers.set(transferId, {
+      transferId,
+      accountId,
+      sessionKey: normalized.sessionKey,
+      route,
+      fileName,
+      mimeType,
+      fileSize,
+      chunkSize,
+      totalChunks,
+      fileSha256,
+      startedAt: runtime.now(),
+      status: 'init',
+      bufferByChunk: new Map(),
+      receivedChunks: new Set(),
+      ownerConnId: connId,
+      ownerClientId: clientId,
+    });
+
+    respond(true, {
+      ok: true,
+      transferId,
+      status: 'init',
+    });
+  };
+}

package/src/plugin/file-inbound-runtime.ts

@@ -0,0 +1,51 @@
+import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import type { BncrRoute, FileRecvTransferState } from '../core/types.ts';
+
+export type BncrFileInboundLeaseEventKind =
+  | 'file.init'
+  | 'file.chunk'
+  | 'file.complete'
+  | 'file.abort';
+
+export type BncrFileInboundRuntime = {
+  asString: (value: unknown, fallback?: string) => string;
+  now: () => number;
+  normalizeAccountId: (accountId: string) => string;
+  finiteNonNegativeNumberOrNull: (value: unknown) => number | null;
+  shouldIgnoreStaleEvent: (args: {
+    kind: BncrFileInboundLeaseEventKind;
+    payload: Record<string, unknown>;
+    accountId: string;
+    connId: string;
+    clientId?: string;
+  }) => boolean;
+  observeLease: (
+    kind: BncrFileInboundLeaseEventKind,
+    payload: Record<string, unknown>,
+  ) => { stale: boolean };
+  matchesTransferOwner: (args: {
+    ownerConnId?: string;
+    ownerClientId?: string;
+    connId: string;
+    clientId?: string;
+  }) => boolean;
+  refreshAcceptedFileTransferLiveState: (args: {
+    accountId: string;
+    connId: string;
+    clientId?: string;
+    context: GatewayRequestHandlerOptions['context'];
+  }) => void;
+  logWarn: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
+  parseRouteLike: (args: { platform: string; groupId: string; userId: string }) => BncrRoute | null;
+  normalizeStoredSessionKey: (
+    sessionKey: string,
+  ) => { sessionKey: string; route: BncrRoute } | null;
+  saveInboundMediaBuffer: (args: {
+    buffer: Buffer;
+    mimeType: string;
+    fileName: string;
+  }) => Promise<{ path: string }>;
+  fileRecvTransfers: Map<string, FileRecvTransferState>;
+  inboundFileTransferMaxBytes: number;
+  inboundFileTransferMaxChunks: number;
+};

package/src/plugin/file-inbound-state.ts

@@ -0,0 +1,62 @@
+import type {
+  FileRecvTransferAbortedState,
+  FileRecvTransferCompletedState,
+  FileRecvTransferInitState,
+  FileRecvTransferState,
+  FileRecvTransferTransferringState,
+} from '../core/types.ts';
+
+export type BncrInboundFileChunkEntry = [number, Buffer];
+
+export function isCompletedInboundTransfer(
+  state: FileRecvTransferState,
+): state is FileRecvTransferCompletedState {
+  return state.status === 'completed';
+}
+
+export function isAbortedInboundTransfer(
+  state: FileRecvTransferState,
+): state is FileRecvTransferAbortedState {
+  return state.status === 'aborted';
+}
+
+export function isActiveInboundTransfer(
+  state: FileRecvTransferState,
+): state is FileRecvTransferInitState | FileRecvTransferTransferringState {
+  return state.status === 'init' || state.status === 'transferring';
+}
+
+export function markInboundTransferCompleted(
+  state: FileRecvTransferState,
+  completedPath: string,
+  terminalAt: number,
+): FileRecvTransferCompletedState {
+  return {
+    ...state,
+    status: 'completed',
+    completedPath,
+    terminalAt,
+  };
+}
+
+export function markInboundTransferTransferring(
+  state: FileRecvTransferInitState | FileRecvTransferTransferringState,
+): FileRecvTransferTransferringState {
+  return {
+    ...state,
+    status: 'transferring',
+  };
+}
+
+export function markInboundTransferAborted(
+  state: FileRecvTransferState,
+  error: string,
+  terminalAt: number,
+): FileRecvTransferAbortedState {
+  return {
+    ...state,
+    status: 'aborted',
+    terminalAt,
+    error,
+  };
+}