uncloud-p2p 1.0.3 → 1.0.4

package/dist/index.d.ts

@@ -49,6 +49,12 @@ export declare class UncloudP2P {
     private updateState;
     private handleError;
     disconnect(): void;
+    /**
+     * Uploads a file, string, or binary buffer to a specific target path on the remote node.
+     * @param targetPath The destination path on the node (e.g., "test/output.txt")
+     * @param content The file content as a string, Blob, File, or ArrayBuffer
+     */
+    uploadFile(targetPath: string, content: string | Blob | File | ArrayBuffer): Promise<void>;
 }
 export * from "./uncloudproto";
 export * from "./files";

package/dist/index.js

@@ -284,6 +284,82 @@ class UncloudP2P {
         this.localCandidates = [];
         this.updateState("idle");
     }
+    /**
+     * Uploads a file, string, or binary buffer to a specific target path on the remote node.
+     * @param targetPath The destination path on the node (e.g., "test/output.txt")
+     * @param content The file content as a string, Blob, File, or ArrayBuffer
+     */
+    async uploadFile(targetPath, content) {
+        if (!this.dc || this.dc.readyState !== "open" || !this.pc) {
+            throw new Error("P2P control channel or peer connection is not established");
+        }
+        // 1. Normalize data input types into a standardized buffer payload
+        let rawDataBuffer;
+        if (typeof content === "string") {
+            rawDataBuffer = new TextEncoder().encode(content).buffer;
+        }
+        else if (content instanceof ArrayBuffer) {
+            rawDataBuffer = content;
+        }
+        else if (content instanceof Blob) {
+            rawDataBuffer = await content.arrayBuffer();
+        }
+        else {
+            throw new Error("Unsupported upload data payload type configuration.");
+        }
+        const fileSize = rawDataBuffer.byteLength;
+        this.log(`Initiating upload handshake sequence for target destination: ${targetPath} (${fileSize} bytes)`);
+        // 2. Alert the control stream channel about our upload metadata context intent
+        // Note: We inject the full structured "targetPath" into the metadata "name" field
+        const controlHandshake = (0, uncloudproto_1.newMessage)(uncloudproto_1.Actions.CLIENT_TO_NODE_FILE_TRANSFER, {
+            name: targetPath,
+            size: fileSize,
+        });
+        this.dc.send(controlHandshake.toJSON());
+        // 3. Construct a temporary WebRTC out-of-band data channel pipe for the file stream blocks
+        const uploadStreamChannel = this.pc.createDataChannel(uncloudproto_1.StreamNames.CLIENT_TO_NODE_FILE_TRANSFER, { ordered: true });
+        // 4. Return an execution promise wrapping the chunk fragmentation loop
+        return new Promise((resolve, reject) => {
+            uploadStreamChannel.onopen = async () => {
+                try {
+                    this.log(`Streaming channel pipe activated. Processing transfer payload...`);
+                    // Send data channel sync context header
+                    const binaryChannelHeader = (0, uncloudproto_1.newMessage)(uncloudproto_1.Actions.CLIENT_TO_NODE_FILE_TRANSFER, {
+                        name: targetPath,
+                        size: fileSize,
+                    });
+                    uploadStreamChannel.send(binaryChannelHeader.toJSON());
+                    // Stream the file data in standard WebRTC payload fragment sizes (16KB chunks)
+                    const CHUNK_SIZE = 16384;
+                    let currentByteOffset = 0;
+                    while (currentByteOffset < fileSize) {
+                        // Guard against overflowing the internal WebRTC browser buffer cache allocations
+                        if (uploadStreamChannel.bufferedAmount > 1024 * 1024) {
+                            await new Promise((r) => setTimeout(r, 25));
+                            continue;
+                        }
+                        const frameEndIndex = Math.min(currentByteOffset + CHUNK_SIZE, fileSize);
+                        const dataSlice = rawDataBuffer.slice(currentByteOffset, frameEndIndex);
+                        uploadStreamChannel.send(dataSlice);
+                        currentByteOffset = frameEndIndex;
+                    }
+                    this.log(`Data payload transfer pipeline complete. Closing stream context map.`, "success");
+                    // Allow internal socket layer flush buffers to breathe before killing context mapping frame references
+                    setTimeout(() => {
+                        uploadStreamChannel.close();
+                        resolve();
+                    }, 800);
+                }
+                catch (streamError) {
+                    uploadStreamChannel.close();
+                    reject(streamError);
+                }
+            };
+            uploadStreamChannel.onerror = (channelErr) => {
+                reject(new Error(`Data transfer stream errored mid-flight: ${channelErr}`));
+            };
+        });
+    }
 }
 exports.UncloudP2P = UncloudP2P;
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uncloud-p2p",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Public Peer to Peer File Reader",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",