test-wuying-agentbay-sdk 0.13.1-beta.20251224094729 → 0.13.1-beta.20251224103203

package/dist/index.mjs

@@ -2218,7 +2218,17 @@ if (!dotEnvLoaded) {
 }
 function loadConfig(customConfig, customEnvPath) {
   if (customConfig) {
-    return customConfig;
+    const config2 = defaultConfig();
+    if (typeof customConfig.endpoint === "string" && customConfig.endpoint) {
+      config2.endpoint = customConfig.endpoint;
+    }
+    if (typeof customConfig.timeout_ms === "number" && Number.isFinite(customConfig.timeout_ms) && customConfig.timeout_ms > 0) {
+      config2.timeout_ms = customConfig.timeout_ms;
+    }
+    if (Object.prototype.hasOwnProperty.call(customConfig, "region_id")) {
+      config2.region_id = customConfig.region_id;
+    }
+    return config2;
   }
   const config = defaultConfig();
   try {
@@ -14322,43 +14332,107 @@ var _FileSystem = class _FileSystem {
    * @param path - Path to the file to read.
    * @param offset - Optional: Byte offset to start reading from (0-based).
    * @param length - Optional: Number of bytes to read. If 0, reads the entire file from offset.
-   * @returns FileContentResult with file content and requestId
+   * @param formatType - Optional: Format to read the file in. "text" (default) or "binary".
+   * @returns FileContentResult for text format, BinaryFileContentResult for binary format
    */
-  async readFileChunk(path6, offset = 0, length = 0) {
+  async readFileChunk(path6, offset = 0, length = 0, formatType = "text") {
     try {
       const args = {
         path: path6
       };
-      if (offset > 0) {
+      if (offset >= 0) {
         args.offset = offset;
       }
-      if (length > 0) {
+      if (length >= 0) {
         args.length = length;
       }
+      if (formatType === "binary") {
+        args.format = "binary";
+      }
       const result = await this.session.callMcpTool(
         "read_file",
         args
       );
       if (!result.success) {
+        if (formatType === "binary") {
+          return {
+            requestId: result.requestId,
+            success: false,
+            content: new Uint8Array(0),
+            errorMessage: result.errorMessage
+          };
+        } else {
+          return {
+            requestId: result.requestId,
+            success: false,
+            content: "",
+            errorMessage: result.errorMessage
+          };
+        }
+      }
+      if (formatType === "binary") {
+        try {
+          if (typeof Buffer !== "undefined") {
+            const base64String = result.data || "";
+            if (base64String) {
+              const base64WithoutPadding = base64String.replace(/=+$/, "");
+              if (!/^[A-Za-z0-9+/]+$/.test(base64WithoutPadding)) {
+                throw new Error("Invalid base64 string format");
+              }
+              const paddingMatch = base64String.match(/=+$/);
+              if (paddingMatch && paddingMatch[0].length > 2) {
+                throw new Error("Invalid base64 padding format");
+              }
+            }
+            const binaryContent = Buffer.from(base64String, "base64");
+            return {
+              requestId: result.requestId,
+              success: true,
+              content: new Uint8Array(binaryContent)
+            };
+          } else {
+            const binaryString = atob(result.data || "");
+            const binaryContent = new Uint8Array(binaryString.length);
+            for (let i = 0; i < binaryString.length; i++) {
+              binaryContent[i] = binaryString.charCodeAt(i);
+            }
+            return {
+              requestId: result.requestId,
+              success: true,
+              content: binaryContent
+            };
+          }
+        } catch (e) {
+          return {
+            requestId: result.requestId,
+            success: false,
+            content: new Uint8Array(0),
+            errorMessage: `Failed to decode base64: ${e}`
+          };
+        }
+      } else {
         return {
           requestId: result.requestId,
+          success: true,
+          content: result.data || ""
+        };
+      }
+    } catch (error) {
+      if (formatType === "binary") {
+        return {
+          requestId: "",
+          success: false,
+          content: new Uint8Array(0),
+          errorMessage: `Failed to read file: ${error}`
+        };
+      } else {
+        return {
+          requestId: "",
           success: false,
           content: "",
-          errorMessage: result.errorMessage
+          errorMessage: `Failed to read file: ${error}`
         };
       }
-      return {
-        requestId: result.requestId,
-        success: true,
-        content: result.data || ""
-      };
-    } catch (error) {
-      return {
-        requestId: "",
-        success: false,
-        content: "",
-        errorMessage: `Failed to read file: ${error}`
-      };
     }
   }
   /**
@@ -14556,120 +14630,178 @@ var _FileSystem = class _FileSystem {
       };
     }
   }
-  /**
-   * Reads the contents of a file. Automatically handles large files by chunking.
-   *
-   * @param path - Path to the file to read.
-   * @returns FileContentResult with complete file content and requestId
-   */
-  /**
-   * Reads the entire content of a file.
-   *
-   * @param path - Absolute path to the file to read.
-   *
-   * @returns Promise resolving to FileContentResult containing:
-   *          - success: Whether the read operation succeeded
-   *          - content: String content of the file
-   *          - requestId: Unique identifier for this API request
-   *          - errorMessage: Error description if read failed
-   *
-   * @throws Error if the API call fails.
-   *
-   * @example
-   * ```typescript
-   * import { AgentBay } from 'wuying-agentbay-sdk';
-   *
-   * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
-   * const result = await agentBay.create();
-   *
-   * if (result.success) {
-   *   const session = result.session;
-   *
-   *   // Read a text file
-   *   const fileResult = await session.fileSystem.readFile('/etc/hostname');
-   *   if (fileResult.success) {
-   *     console.log(`Content: ${fileResult.content}`);
-   *     // Output: Content: agentbay-session-xyz
-   *   }
-   *
-   *   await session.delete();
-   * }
-   * ```
-   *
-   * @remarks
-   * **Behavior:**
-   * - Automatically handles large files by reading in 60KB chunks
-   * - Returns empty string for empty files
-   * - Fails if path is a directory or doesn't exist
-   * - Content is returned as UTF-8 string
-   *
-   * @see {@link writeFile}, {@link listDirectory}
-   */
-  async readFile(path6) {
+  async readFile(path6, opts) {
+    const format = opts?.format || "text";
     const chunkSize = DEFAULT_CHUNK_SIZE;
     try {
       const fileInfoResult = await this.getFileInfo(path6);
       if (!fileInfoResult.success) {
-        return {
-          requestId: fileInfoResult.requestId,
-          success: false,
-          content: "",
-          errorMessage: fileInfoResult.errorMessage
-        };
+        if (format === "bytes") {
+          return {
+            requestId: fileInfoResult.requestId,
+            success: false,
+            content: new Uint8Array(0),
+            errorMessage: fileInfoResult.errorMessage
+          };
+        } else {
+          return {
+            requestId: fileInfoResult.requestId,
+            success: false,
+            content: "",
+            errorMessage: fileInfoResult.errorMessage
+          };
+        }
       }
       if (!fileInfoResult.fileInfo || fileInfoResult.fileInfo.isDirectory) {
-        return {
-          requestId: fileInfoResult.requestId,
-          success: false,
-          content: "",
-          errorMessage: `Path does not exist or is a directory: ${path6}`
-        };
+        const errorMsg = `Path does not exist or is a directory: ${path6}`;
+        if (format === "bytes") {
+          return {
+            requestId: fileInfoResult.requestId,
+            success: false,
+            content: new Uint8Array(0),
+            errorMessage: errorMsg
+          };
+        } else {
+          return {
+            requestId: fileInfoResult.requestId,
+            success: false,
+            content: "",
+            errorMessage: errorMsg
+          };
+        }
       }
       const fileSize = fileInfoResult.fileInfo.size || 0;
       if (fileSize === 0) {
+        if (format === "bytes") {
+          return {
+            requestId: fileInfoResult.requestId,
+            success: true,
+            content: new Uint8Array(0),
+            size: 0
+          };
+        } else {
+          return {
+            requestId: fileInfoResult.requestId,
+            success: true,
+            content: ""
+          };
+        }
+      }
+      if (format === "bytes") {
+        const contentChunks = [];
+        let offset = 0;
+        let chunkCount = 0;
+        while (offset < fileSize) {
+          let length = chunkSize;
+          if (offset + length > fileSize) {
+            length = fileSize - offset;
+          }
+          try {
+            const chunkResult = await this.readFileChunk(
+              path6,
+              offset,
+              length,
+              "binary"
+            );
+            if (!chunkResult.success) {
+              return chunkResult;
+            }
+            if ("content" in chunkResult && chunkResult.content instanceof Uint8Array) {
+              contentChunks.push(chunkResult.content);
+            } else {
+              return {
+                requestId: chunkResult.requestId,
+                success: false,
+                content: new Uint8Array(0),
+                errorMessage: "Unexpected result type for binary format"
+              };
+            }
+            offset += length;
+            chunkCount++;
+          } catch (error) {
+            return {
+              requestId: fileInfoResult.requestId,
+              success: false,
+              content: new Uint8Array(0),
+              errorMessage: `Error reading chunk at offset ${offset}: ${error}`
+            };
+          }
+        }
+        const totalLength = contentChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const finalContent = new Uint8Array(totalLength);
+        let position = 0;
+        for (const chunk of contentChunks) {
+          finalContent.set(chunk, position);
+          position += chunk.length;
+        }
         return {
           requestId: fileInfoResult.requestId,
           success: true,
-          content: ""
+          content: finalContent,
+          size: finalContent.length
         };
-      }
-      let result = "";
-      let offset = 0;
-      let chunkCount = 0;
-      while (offset < fileSize) {
-        let length = chunkSize;
-        if (offset + length > fileSize) {
-          length = fileSize - offset;
-        }
-        try {
-          const chunkResult = await this.readFileChunk(path6, offset, length);
-          if (!chunkResult.success) {
-            return chunkResult;
+      } else {
+        let result = "";
+        let offset = 0;
+        let chunkCount = 0;
+        while (offset < fileSize) {
+          let length = chunkSize;
+          if (offset + length > fileSize) {
+            length = fileSize - offset;
+          }
+          try {
+            const chunkResult = await this.readFileChunk(
+              path6,
+              offset,
+              length,
+              "text"
+            );
+            if (!chunkResult.success) {
+              return chunkResult;
+            }
+            if ("content" in chunkResult && typeof chunkResult.content === "string") {
+              result += chunkResult.content;
+            } else {
+              return {
+                requestId: chunkResult.requestId,
+                success: false,
+                content: "",
+                errorMessage: "Unexpected result type for text format"
+              };
+            }
+            offset += length;
+            chunkCount++;
+          } catch (error) {
+            return {
+              requestId: fileInfoResult.requestId,
+              success: false,
+              content: "",
+              errorMessage: `Error reading chunk at offset ${offset}: ${error}`
+            };
           }
-          result += chunkResult.content;
-          offset += length;
-          chunkCount++;
-        } catch (error) {
-          return {
-            requestId: fileInfoResult.requestId,
-            success: false,
-            content: "",
-            errorMessage: `Error reading chunk at offset ${offset}: ${error}`
-          };
         }
+        return {
+          requestId: fileInfoResult.requestId,
+          success: true,
+          content: result
+        };
       }
-      return {
-        requestId: fileInfoResult.requestId,
-        success: true,
-        content: result
-      };
     } catch (error) {
-      return {
-        requestId: "",
-        success: false,
-        content: "",
-        errorMessage: `Failed to read large file: ${error}`
-      };
+      if (format === "bytes") {
+        return {
+          requestId: "",
+          success: false,
+          content: new Uint8Array(0),
+          errorMessage: `Failed to read large file: ${error}`
+        };
+      } else {
+        return {
+          requestId: "",
+          success: false,
+          content: "",
+          errorMessage: `Failed to read large file: ${error}`
+        };
+      }
     }
   }
   /**
@@ -19724,6 +19856,7 @@ export {
   Mobile,
   MobileSimulateMode,
   MobileSimulateService,
+  MobileUseAgent,
   ModifyContextRequest,
   ModifyContextResponse,
   ModifyContextResponseBody,