test-wuying-agentbay-sdk 0.13.1-beta.20251224091333 → 0.13.1-beta.20251224100120

package/dist/index.mjs

@@ -2325,11 +2325,20 @@ var LOG_LEVEL_VALUES = {
 };
 var currentRequestId = "";
 var currentLogLevel = process.env.LOG_LEVEL || process.env.AGENTBAY_LOG_LEVEL || "INFO";
+var currentLogFormat = process.env.AGENTBAY_LOG_FORMAT || "pretty";
+if (["sls", "compact"].includes(String(currentLogFormat).toLowerCase())) {
+  currentLogFormat = "sls";
+} else {
+  currentLogFormat = "pretty";
+}
 var fileLoggingEnabled = false;
 var logFilePath = null;
 var logFileMaxSize = 10 * 1024 * 1024;
 var consoleLoggingEnabled = true;
 function shouldUseColors() {
+  if (currentLogFormat === "sls") {
+    return false;
+  }
   if (process.env.DISABLE_COLORS === "true") {
     return false;
   }
@@ -2371,6 +2380,9 @@ var SENSITIVE_FIELDS = [
   "authorization"
 ];
 function getLogLevelEmoji(level) {
+  if (currentLogFormat === "sls") {
+    return level;
+  }
   switch (level) {
     case "DEBUG":
       return "\u{1F41B} DEBUG";
@@ -2390,6 +2402,13 @@ function shouldLog(level) {
 }
 __name(shouldLog, "shouldLog");
 function formatLogMessage(level, message, forFile = false) {
+  if (currentLogFormat === "sls") {
+    let formattedMessage2 = `${level}: ${message}`;
+    if (currentRequestId) {
+      formattedMessage2 += ` [RequestId=${currentRequestId}]`;
+    }
+    return formattedMessage2;
+  }
   let formattedMessage = `${getLogLevelEmoji(level)}: ${message}`;
   if (currentRequestId) {
     formattedMessage += ` [RequestId=${currentRequestId}]`;
@@ -2537,6 +2556,23 @@ function setupLogger(config) {
   if (config.enableConsole !== void 0) {
     consoleLoggingEnabled = config.enableConsole;
   }
+  if (config.format) {
+    if (["sls", "compact"].includes(String(config.format).toLowerCase())) {
+      currentLogFormat = "sls";
+    } else {
+      currentLogFormat = "pretty";
+    }
+  } else {
+    const envFormat = process.env.AGENTBAY_LOG_FORMAT;
+    if (envFormat) {
+      if (["sls", "compact"].includes(String(envFormat).toLowerCase())) {
+        currentLogFormat = "sls";
+      } else {
+        currentLogFormat = "pretty";
+      }
+    }
+  }
+  useColors = shouldUseColors();
 }
 __name(setupLogger, "setupLogger");
 function log(message, ...args) {
@@ -2644,6 +2680,22 @@ ${error.stack}`;
 __name(logError, "logError");
 function logAPICall(apiName, requestData) {
   if (!shouldLog("INFO")) return;
+  if (currentLogFormat === "sls") {
+    let message2 = `API Call: ${apiName}`;
+    if (requestData) {
+      const maskedData = maskSensitiveData(requestData);
+      if (typeof maskedData === "string") {
+        message2 += `, ${maskedData}`;
+      } else {
+        message2 += `, ${JSON.stringify(maskedData)}`;
+      }
+    }
+    if (consoleLoggingEnabled) {
+      process.stdout.write(message2 + "\n");
+    }
+    writeToFile(message2);
+    return;
+  }
   const message = `\u{1F517} API Call: ${apiName}`;
   const savedRequestId = currentRequestId;
   currentRequestId = "";
@@ -2661,6 +2713,35 @@ function logAPICall(apiName, requestData) {
 }
 __name(logAPICall, "logAPICall");
 function logAPIResponseWithDetails(apiName, requestId, success = true, keyFields, fullResponse) {
+  if (currentLogFormat === "sls") {
+    if (!shouldLog(success ? "INFO" : "ERROR")) return;
+    const status = success ? "API Response" : "API Response Failed";
+    let msg = `${status}: ${apiName}`;
+    if (requestId) {
+      msg += `, RequestId=${requestId}`;
+    }
+    if (keyFields) {
+      for (const [key, value] of Object.entries(keyFields)) {
+        const maskedValue = maskSensitiveData({ [key]: value });
+        msg += `, ${key}=${maskedValue[key]}`;
+      }
+    }
+    if (success) {
+      if (consoleLoggingEnabled) {
+        process.stdout.write(msg + "\n");
+      }
+      writeToFile(msg);
+    } else {
+      if (consoleLoggingEnabled) {
+        process.stderr.write(msg + "\n");
+      }
+      writeToFile(msg);
+    }
+    if (fullResponse && shouldLog("DEBUG")) {
+      logDebug(`Full Response: ${fullResponse}`);
+    }
+    return;
+  }
   if (success) {
     if (shouldLog("INFO")) {
       let mainMessage = `\u2705 API Response: ${apiName}`;
@@ -2732,6 +2813,16 @@ function logCodeExecutionOutput(requestId, rawOutput) {
       return;
     }
     const actualOutput = texts.join("");
+    if (currentLogFormat === "sls") {
+      const header2 = `Code Execution Output (RequestID: ${requestId}):`;
+      if (consoleLoggingEnabled) {
+        process.stdout.write(header2 + "\n");
+        process.stdout.write(actualOutput + "\n");
+      }
+      writeToFile(header2);
+      writeToFile(actualOutput);
+      return;
+    }
     const header = `\u{1F4CB} Code Execution Output (RequestID: ${requestId}):`;
     if (useColors) {
       process.stdout.write(`${ANSI_GREEN}\u2139\uFE0F  INFO: ${header}${ANSI_RESET}
@@ -2761,6 +2852,10 @@ function logCodeExecutionOutput(requestId, rawOutput) {
 __name(logCodeExecutionOutput, "logCodeExecutionOutput");
 function logInfoWithColor(message, color = ANSI_RED) {
   if (!shouldLog("INFO")) return;
+  if (currentLogFormat === "sls") {
+    logInfo(message);
+    return;
+  }
   const emoji = "\u2139\uFE0F  INFO";
   const fullMessage = `${emoji}: ${message}`;
   if (useColors) {
@@ -14227,43 +14322,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}`
-      };
     }
   }
   /**
@@ -14461,120 +14620,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}`
+        };
+      }
     }
   }
   /**