@unboundcx/sdk 2.8.11 → 4.0.1

package/base.js

@@ -297,6 +297,17 @@ export class BaseSDK {
       return true;
     }
 
+    // Streaming bodies (Node Readable or Web ReadableStream) — caller is
+    // expected to set an explicit content-type header alongside.
+    if (
+      typeof body === 'object' &&
+      body !== null &&
+      (typeof body.pipe === 'function' ||
+        typeof body.getReader === 'function')
+    ) {
+      return true;
+    }
+
     return false;
   }
 
@@ -353,9 +364,20 @@ export class BaseSDK {
         typeof Buffer !== 'undefined' &&
         Buffer.isBuffer &&
         Buffer.isBuffer(body);
+      const isStream =
+        body &&
+        typeof body === 'object' &&
+        (typeof body.pipe === 'function' ||
+          typeof body.getReader === 'function');
 
       if (isFormData || isBuffer) {
         options.body = body;
+      } else if (isStream) {
+        // Node 18+ native fetch (undici) requires duplex: 'half' for
+        // streaming request bodies. Without this the fetch throws
+        // synchronously before the first byte is sent.
+        options.body = body;
+        options.duplex = 'half';
       } else {
         options.body = JSON.stringify(body);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "2.8.11",
+  "version": "4.0.1",
   "description": "Official JavaScript SDK for the Unbound API - A comprehensive toolkit for integrating with Unbound's communication, AI, and data management services",
   "main": "index.js",
   "type": "module",
@@ -59,7 +59,7 @@
   },
   "scripts": {
     "build": "echo 'Build complete - ESM modules ready'",
-    "test": "echo 'Tests would run here'",
+    "test": "node --test 'test/*.test.js'",
     "lint": "echo 'Linting would run here'",
     "prepublishOnly": "npm run build"
   },

package/services/storage.js

@@ -87,6 +87,69 @@ export class StorageService {
     return commonTypes[ext] || 'application/octet-stream';
   }
 
+  // Private helper to detect if a value is a Node Readable or Web ReadableStream
+  _isStreamLike(value) {
+    if (!value || typeof value !== 'object') return false;
+    if (typeof value.pipe === 'function') return true; // Node Readable
+    if (typeof value.getReader === 'function') return true; // Web ReadableStream
+    if (typeof value[Symbol.asyncIterator] === 'function') return true;
+    return false;
+  }
+
+  // Private helper to create a streaming multipart body for Node.js.
+  // Returns { body: ReadableStream, headers } for fetch() with duplex: 'half'.
+  // Byte-identical framing to _createNodeFormData — emitted in chunks so the full
+  // file never has to sit in memory.
+  _createNodeFormDataStream(fileStream, fileName, formFields) {
+    const boundary = `----formdata-${Date.now()}-${Math.random()
+      .toString(36)
+      .slice(2)}`;
+    const CRLF = '\r\n';
+    const contentType = this._getContentType(fileName);
+
+    const header =
+      `--${boundary}${CRLF}` +
+      `Content-Disposition: form-data; name="files"; filename="${
+        fileName || 'file'
+      }"${CRLF}` +
+      `Content-Type: ${contentType}${CRLF}${CRLF}`;
+
+    let tail = '';
+    for (const [name, value] of formFields) {
+      tail += `${CRLF}--${boundary}${CRLF}Content-Disposition: form-data; name="${name}"${CRLF}${CRLF}${value}`;
+    }
+    tail += `${CRLF}--${boundary}--${CRLF}`;
+
+    const body = new ReadableStream({
+      async start(controller) {
+        try {
+          controller.enqueue(Buffer.from(header, 'utf8'));
+          for await (const chunk of fileStream) {
+            controller.enqueue(
+              Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk),
+            );
+          }
+          controller.enqueue(Buffer.from(tail, 'utf8'));
+          controller.close();
+        } catch (err) {
+          controller.error(err);
+        }
+      },
+      cancel(reason) {
+        if (fileStream && typeof fileStream.destroy === 'function') {
+          fileStream.destroy(reason);
+        }
+      },
+    });
+
+    return {
+      body,
+      headers: {
+        'content-type': `multipart/form-data; boundary=${boundary}`,
+      },
+    };
+  }
+
   // Private helper to create FormData for Node.js environment
   _createNodeFormData(file, fileName, formFields) {
     const boundary = `----formdata-${Date.now()}-${Math.random().toString(36)}`;
@@ -234,7 +297,13 @@ export class StorageService {
     // Default behavior: Use fetch via sdk._fetch
     let formData, headers;
 
-    if (isNode) {
+    if (isNode && this._isStreamLike(file)) {
+      // Streaming path — file is piped chunk-by-chunk, no full-buffer copy.
+      // Caller is responsible for creating a fresh stream per retry.
+      const result = this._createNodeFormDataStream(file, fileName, formFields);
+      formData = result.body;
+      headers = result.headers;
+    } else if (isNode) {
       const result = this._createNodeFormData(file, fileName, formFields);
       formData = result.formData;
       headers = result.headers;
@@ -381,7 +450,7 @@ Response:
   /**
    * Upload a file to storage with optional format conversion
    * @param {Object} config - Configuration object
-   * @param {Object} config.file - File content (Buffer or File) - REQUIRED
+   * @param {Object} config.file - File content: Buffer, File, Node Readable stream, or Web ReadableStream. Streams upload chunk-by-chunk (no full-buffer copy) — recommended for files > ~100 MB. For retries, create a fresh stream per attempt. REQUIRED
    * @param {string} [config.classification='generic'] - File classification (e.g., 'fax', 'files', 'generic')
    * @param {string} [config.folder] - Folder path for organizing files
    * @param {string} [config.fileName] - Original file name

package/services/video.js

@@ -503,6 +503,27 @@ export class VideoService {
     return result;
   }
 
+  /**
+   * Validate a guest JWT for a video room. Used by app1-socket's
+   * `authorizeVideoSocketConnection` middleware during the `/video` Socket.IO
+   * handshake to decide whether to admit the connection.
+   *
+   * @param {string} id - videoRoom id (must match the token's `roomId` claim)
+   * @param {string} [token] - raw JWT. Omit to let the server read it from
+   *   the `videoAuthToken` cookie on the SDK's request.
+   * @returns {Promise<{
+   *   valid: boolean,
+   *   account: { id: string, namespace: string, accountCode: string },
+   *   participant: Object,
+   *   token: { id: string, type: 'videoRoomGuest', expiresAt: string },
+   *   videoRoom: Object,
+   *   podName: string,
+   * }>} The `podName` field (added with centralized signaling) is the
+   * video-server pod assigned to this room at token-mint time, re-validated
+   * against app1-api's live podRegistry. If the pod is no longer alive the
+   * server returns HTTP 409 `POD_UNAVAILABLE` — the client reacts by calling
+   * `/video/rooms/:id/join` for a fresh assignment.
+   */
   async validateGuestToken(id, token) {
     this.sdk.validateParams(
       { id, token },
@@ -524,6 +545,52 @@ export class VideoService {
     return result;
   }
 
+  /**
+   * Construct a `VideoMeetingClient` configured for this SDK instance.
+   *
+   * Dynamically imports `@unboundcx/video-sdk-client` so WebRTC peer deps
+   * (`mediasoup-client`, `socket.io-client`) stay out of backend bundles that
+   * never touch video. Returns a client with `this` SDK injected so it can
+   * transparently call `sdk.video.joinRoom()` for reassignment recovery and
+   * `sdk.video.endSession()` on leave.
+   *
+   * **Bundler note**: SvelteKit/Vite handle the dynamic import natively. If
+   * you use a bundler that eagerly resolves imports, pin the import path or
+   * ensure the package is marked external.
+   *
+   * @param {Object} [options] - Forwarded to the `VideoMeetingClient` constructor
+   * @returns {Promise<import('@unboundcx/video-sdk-client').VideoMeetingClient>}
+   */
+  async createMeetingClient(options = {}) {
+    const { VideoMeetingClient } = await import('@unboundcx/video-sdk-client');
+    return new VideoMeetingClient({ ...options, sdk: this.sdk });
+  }
+
+  /**
+   * End the meeting session server-side. Invalidates the token row in the
+   * `tokens` table and clears the `videoAuthToken` cookie so a stale cookie
+   * from a prior meeting can't be replayed.
+   *
+   * The endpoint is deliberately permissive: accepts expired and
+   * room-mismatched cookies and never returns 401/403 — rejection would
+   * strand stale cookies.
+   *
+   * @param {string} roomId
+   */
+  async endSession(roomId) {
+    this.sdk.validateParams(
+      { roomId },
+      { roomId: { type: 'string', required: true } },
+    );
+    const result = await this.sdk._fetch(
+      `/video/session/end`,
+      'POST',
+      { body: { roomId } },
+      true,
+    );
+    return result;
+  }
+
   async logStats(roomId, stats) {
     this.sdk.validateParams(
       { roomId, stats },