wuying-agentbay-sdk 0.4.0 → 0.4.2

package/dist/index.mjs

@@ -6026,10 +6026,62 @@ var _Session = class _Session {
   /**
    * Delete this session.
    *
+   * @param syncContext - Whether to sync context data (trigger file uploads) before deleting the session. Defaults to false.
    * @returns DeleteResult indicating success or failure and request ID
    */
-  async delete() {
+  async delete(syncContext = false) {
     try {
+      if (syncContext) {
+        log("Triggering context synchronization before session deletion...");
+        try {
+          const syncResult = await this.context.sync();
+          if (!syncResult.success) {
+            log("Warning: Context sync operation returned failure status");
+          }
+        } catch (error) {
+          logError("Warning: Failed to trigger context sync:", error);
+        }
+        const maxRetries = 150;
+        const retryInterval = 2e3;
+        for (let retry = 0; retry < maxRetries; retry++) {
+          try {
+            const infoResult = await this.context.info();
+            let allCompleted = true;
+            let hasFailure = false;
+            let hasUploads = false;
+            for (const item of infoResult.contextStatusData) {
+              if (item.taskType !== "upload") {
+                continue;
+              }
+              hasUploads = true;
+              log(`Upload context ${item.contextId} status: ${item.status}, path: ${item.path}`);
+              if (item.status !== "Success" && item.status !== "Failed") {
+                allCompleted = false;
+                break;
+              }
+              if (item.status === "Failed") {
+                hasFailure = true;
+                logError(`Upload failed for context ${item.contextId}: ${item.errorMessage}`);
+              }
+            }
+            if (allCompleted || !hasUploads) {
+              if (hasFailure) {
+                log("Context upload completed with failures");
+              } else if (hasUploads) {
+                log("Context upload completed successfully");
+              } else {
+                log("No upload tasks found");
+              }
+              break;
+            }
+            log(`Waiting for context upload to complete, attempt ${retry + 1}/${maxRetries}`);
+            await new Promise((resolve2) => setTimeout(resolve2, retryInterval));
+          } catch (error) {
+            logError(`Error checking context status on attempt ${retry + 1}:`, error);
+            await new Promise((resolve2) => setTimeout(resolve2, retryInterval));
+          }
+        }
+      }
       const request = new ReleaseMcpSessionRequest({
         authorization: `Bearer ${this.getAPIKey()}`,
         sessionId: this.sessionId
@@ -6333,19 +6385,21 @@ var _AgentBay = class _AgentBay {
       if (params.imageId) {
         request.imageId = params.imageId;
       }
+      let hasPersistenceData = false;
       if (params.contextSync && params.contextSync.length > 0) {
         const persistenceDataList = [];
         for (const contextSync of params.contextSync) {
-          const persistenceItem = {
+          const persistenceItem = new CreateMcpSessionRequestPersistenceDataList({
             contextId: contextSync.contextId,
             path: contextSync.path
-          };
+          });
           if (contextSync.policy) {
             persistenceItem.policy = JSON.stringify(contextSync.policy);
           }
           persistenceDataList.push(persistenceItem);
         }
         request.persistenceDataList = persistenceDataList;
+        hasPersistenceData = persistenceDataList.length > 0;
       }
       log("API Call: CreateMcpSession");
       let requestLog = "Request: ";
@@ -6404,6 +6458,42 @@ var _AgentBay = class _AgentBay {
         session.resourceUrl = resourceUrl;
       }
       this.sessions.set(session.sessionId, session);
+      if (hasPersistenceData) {
+        log("Waiting for context synchronization to complete...");
+        const maxRetries = 150;
+        const retryInterval = 2e3;
+        for (let retry = 0; retry < maxRetries; retry++) {
+          try {
+            const infoResult = await session.context.info();
+            let allCompleted = true;
+            let hasFailure = false;
+            for (const item of infoResult.contextStatusData) {
+              log(`Context ${item.contextId} status: ${item.status}, path: ${item.path}`);
+              if (item.status !== "Success" && item.status !== "Failed") {
+                allCompleted = false;
+                break;
+              }
+              if (item.status === "Failed") {
+                hasFailure = true;
+                logError(`Context synchronization failed for ${item.contextId}: ${item.errorMessage}`);
+              }
+            }
+            if (allCompleted || infoResult.contextStatusData.length === 0) {
+              if (hasFailure) {
+                log("Context synchronization completed with failures");
+              } else {
+                log("Context synchronization completed successfully");
+              }
+              break;
+            }
+            log(`Waiting for context synchronization, attempt ${retry + 1}/${maxRetries}`);
+            await new Promise((resolve2) => setTimeout(resolve2, retryInterval));
+          } catch (error) {
+            logError(`Error checking context status on attempt ${retry + 1}: ${error}`);
+            await new Promise((resolve2) => setTimeout(resolve2, retryInterval));
+          }
+        }
+      }
       return {
         requestId,
         success: true,
@@ -6516,11 +6606,12 @@ var _AgentBay = class _AgentBay {
    * Delete a session by session object.
    *
    * @param session - The session to delete.
+   * @param syncContext - Whether to sync context data (trigger file uploads) before deleting the session. Defaults to false.
    * @returns DeleteResult indicating success or failure and request ID
    */
-  async delete(session) {
+  async delete(session, syncContext = false) {
     try {
-      const deleteResult = await session.delete();
+      const deleteResult = await session.delete(syncContext);
       this.sessions.delete(session.sessionId);
       return deleteResult;
     } catch (error) {
@@ -6549,6 +6640,171 @@ var _AgentBay = class _AgentBay {
 };
 __name(_AgentBay, "AgentBay");
 var AgentBay = _AgentBay;
+
+// src/context-sync.ts
+init_esm_shims();
+var UploadStrategy = /* @__PURE__ */ ((UploadStrategy2) => {
+  UploadStrategy2["UploadBeforeResourceRelease"] = "UploadBeforeResourceRelease";
+  return UploadStrategy2;
+})(UploadStrategy || {});
+var DownloadStrategy = /* @__PURE__ */ ((DownloadStrategy2) => {
+  DownloadStrategy2["DownloadAsync"] = "DownloadAsync";
+  return DownloadStrategy2;
+})(DownloadStrategy || {});
+var _ContextSync = class _ContextSync {
+  constructor(contextId, path3, policy) {
+    this.contextId = contextId;
+    this.path = path3;
+    this.policy = policy;
+  }
+  // WithPolicy sets the policy and returns the context sync for chaining
+  withPolicy(policy) {
+    this.policy = policy;
+    return this;
+  }
+};
+__name(_ContextSync, "ContextSync");
+var ContextSync = _ContextSync;
+function newUploadPolicy() {
+  return {
+    autoUpload: true,
+    uploadStrategy: "UploadBeforeResourceRelease" /* UploadBeforeResourceRelease */,
+    period: 30
+    // Default to 30 minutes
+  };
+}
+__name(newUploadPolicy, "newUploadPolicy");
+function newDownloadPolicy() {
+  return {
+    autoDownload: true,
+    downloadStrategy: "DownloadAsync" /* DownloadAsync */
+  };
+}
+__name(newDownloadPolicy, "newDownloadPolicy");
+function newDeletePolicy() {
+  return {
+    syncLocalFile: true
+  };
+}
+__name(newDeletePolicy, "newDeletePolicy");
+function newSyncPolicy() {
+  return {
+    uploadPolicy: newUploadPolicy(),
+    downloadPolicy: newDownloadPolicy(),
+    deletePolicy: newDeletePolicy(),
+    bwList: {
+      whiteLists: [
+        {
+          path: "",
+          excludePaths: []
+        }
+      ]
+    }
+  };
+}
+__name(newSyncPolicy, "newSyncPolicy");
+function newContextSync(contextId, path3, policy) {
+  return new ContextSync(contextId, path3, policy);
+}
+__name(newContextSync, "newContextSync");
+
+// src/session-params.ts
+init_esm_shims();
+var _CreateSessionParams = class _CreateSessionParams {
+  constructor() {
+    this.labels = {};
+    this.contextSync = [];
+  }
+  /**
+   * WithLabels sets the labels for the session parameters and returns the updated parameters.
+   */
+  withLabels(labels) {
+    this.labels = labels;
+    return this;
+  }
+  /**
+   * WithContextID sets the context ID for the session parameters and returns the updated parameters.
+   */
+  withContextID(contextId) {
+    this.contextId = contextId;
+    return this;
+  }
+  /**
+   * WithImageId sets the image ID for the session parameters and returns the updated parameters.
+   */
+  withImageId(imageId) {
+    this.imageId = imageId;
+    return this;
+  }
+  /**
+   * GetLabelsJSON returns the labels as a JSON string.
+   * Returns an object with success status and result/error message to match Go version behavior.
+   */
+  getLabelsJSON() {
+    if (Object.keys(this.labels).length === 0) {
+      return { result: "" };
+    }
+    try {
+      const labelsJSON = JSON.stringify(this.labels);
+      return { result: labelsJSON };
+    } catch (error) {
+      return {
+        result: "",
+        error: `Failed to marshal labels to JSON: ${error}`
+      };
+    }
+  }
+  /**
+   * AddContextSync adds a context sync configuration to the session parameters.
+   */
+  addContextSync(contextId, path3, policy) {
+    const contextSync = new ContextSync(contextId, path3, policy);
+    this.contextSync.push(contextSync);
+    return this;
+  }
+  /**
+   * AddContextSyncConfig adds a pre-configured context sync to the session parameters.
+   */
+  addContextSyncConfig(contextSync) {
+    this.contextSync.push(contextSync);
+    return this;
+  }
+  /**
+   * WithContextSync sets the context sync configurations for the session parameters.
+   */
+  withContextSync(contextSyncs) {
+    this.contextSync = contextSyncs;
+    return this;
+  }
+  /**
+   * Convert to plain object for JSON serialization
+   */
+  toJSON() {
+    return {
+      labels: this.labels,
+      contextId: this.contextId,
+      imageId: this.imageId,
+      contextSync: this.contextSync
+    };
+  }
+  /**
+   * Create from plain object
+   */
+  static fromJSON(config) {
+    const params = new _CreateSessionParams();
+    params.labels = config.labels || {};
+    params.contextId = config.contextId;
+    params.imageId = config.imageId;
+    params.contextSync = config.contextSync || [];
+    return params;
+  }
+};
+__name(_CreateSessionParams, "CreateSessionParams");
+var CreateSessionParams = _CreateSessionParams;
+function newCreateSessionParams() {
+  return new CreateSessionParams();
+}
+__name(newCreateSessionParams, "newCreateSessionParams");
 export {
   APIError,
   AgentBay,
@@ -6567,16 +6823,20 @@ export {
   Command,
   CommandError,
   Context,
+  ContextManager,
   ContextService,
+  ContextSync,
   CreateMcpSessionRequest,
   CreateMcpSessionRequestPersistenceDataList,
   CreateMcpSessionResponse,
   CreateMcpSessionResponseBody,
   CreateMcpSessionResponseBodyData,
   CreateMcpSessionShrinkRequest,
+  CreateSessionParams,
   DeleteContextRequest,
   DeleteContextResponse,
   DeleteContextResponseBody,
+  DownloadStrategy,
   FileError,
   FileSystem,
   GetContextInfoRequest,
@@ -6630,8 +6890,16 @@ export {
   SyncContextResponseBody,
   UI,
   UIError,
+  UploadStrategy,
   log,
-  logError
+  logError,
+  newContextManager,
+  newContextSync,
+  newCreateSessionParams,
+  newDeletePolicy,
+  newDownloadPolicy,
+  newSyncPolicy,
+  newUploadPolicy
 };
 //# sourceMappingURL=index.mjs.map