uncloud-p2p 1.0.2 → 1.0.4

package/README.md

@@ -1 +1,3 @@
-# uncloud-p2p
+# uncloud-p2p
+
+https://uncloud.mpsoftware.io/docs/uncloud-p2p coming soon

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export interface IceCandidate {
 export interface IceExchangePayload {
     sdp: string;
     candidates: IceCandidate[];
+    token: string;
 }
 export type ConnectionState = "idle" | "gathering" | "signaling" | "connecting" | "connected" | "disconnected" | "error";
 interface P2POptions {
@@ -24,6 +25,7 @@ export declare class UncloudP2P {
     private options;
     private pendingRequests;
     private pendingDownloads;
+    private token;
     constructor(options: P2POptions);
     private log;
     /**
@@ -47,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

@@ -23,6 +23,7 @@ class UncloudP2P {
         this.localCandidates = [];
         this.pendingRequests = new Map();
         this.pendingDownloads = new Map();
+        this.token = "";
         this.options = {
             baseUrl: "https://uncloud.mpsoftware.io",
             iceServers: [{ urls: "stun:stun.l.google.com:19302" }],
@@ -70,6 +71,11 @@ class UncloudP2P {
             };
             const offer = await this.pc.createOffer();
             await this.pc.setLocalDescription(offer);
+            await this.waitForOpen();
+            // finally, set our token so the node knows what grants we were given from the p2p public link
+            const resp = await this.sendCommand(uncloudproto_1.Actions.SET_TOKEN, {
+                token: this.token,
+            });
         }
         catch (err) {
             this.handleError(err);
@@ -85,6 +91,7 @@ class UncloudP2P {
         const payload = {
             sdp: this.pc.localDescription.sdp,
             candidates: this.localCandidates,
+            token: "", // we get this back from the node
         };
         try {
             const endpoint = `${this.options.baseUrl}/api/public/node/${this.options.nodeId}/exchangeCandidates`;
@@ -96,6 +103,7 @@ class UncloudP2P {
             if (!response.ok)
                 throw new Error(`HTTP error! status: ${response.status}`);
             const nodeResponse = await response.json();
+            this.token = nodeResponse.token;
             await this.pc.setRemoteDescription(new RTCSessionDescription({ type: "answer", sdp: nodeResponse.sdp }));
             for (const cand of nodeResponse.candidates) {
                 await this.pc.addIceCandidate(cand);
@@ -141,7 +149,16 @@ class UncloudP2P {
                         pending.reject(response.error);
                     }
                     else {
-                        pending.resolve(response.body);
+                        // check if body is 1 field and is an error field
+                        if (response.body &&
+                            typeof response.body === "object" &&
+                            "error" in response.body &&
+                            Object.keys(response.body).length === 1) {
+                            pending.reject(response.body.error);
+                        }
+                        else {
+                            pending.resolve(response.body);
+                        }
                     }
                     return;
                 }
@@ -215,7 +232,7 @@ class UncloudP2P {
             this.pendingDownloads.set(fileName, { resolve, reject });
             try {
                 // 2. Trigger the request
-                await this.sendCommand(uncloudproto_1.Actions.NODE_TO_CLIENT_FILE_TRANSFER, {
+                const resp = await this.sendCommand(uncloudproto_1.Actions.NODE_TO_CLIENT_FILE_TRANSFER, {
                     name: fileName,
                 });
             }
@@ -267,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/dist/uncloudproto.d.ts

@@ -24,6 +24,7 @@ export declare const Actions: {
     CLIENT_TO_NODE_FILE_TRANSFER: string;
     NODE_TO_CLIENT_FILE_TRANSFER: string;
     CLIENT_TO_NODE_LIST_FILES: string;
+    SET_TOKEN: string;
 };
 export type Action = (typeof Actions)[keyof typeof Actions];
 export type PendingRequest = {

package/dist/uncloudproto.js

@@ -41,4 +41,5 @@ exports.Actions = {
     CLIENT_TO_NODE_FILE_TRANSFER: "client_to_node_file_transfer",
     NODE_TO_CLIENT_FILE_TRANSFER: "node_to_client_file_transfer",
     CLIENT_TO_NODE_LIST_FILES: "client_to_node_list_files",
+    SET_TOKEN: "set_token",
 };

package/package.json

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