lexmount 0.2.0 → 0.2.3

package/dist/index.mjs

@@ -402,13 +402,120 @@ var ContextsResource = class {
   }
 };
 
-// src/sessions.ts
+// src/extensions.ts
+import { readFile } from "fs/promises";
+import path from "path";
 function asRecord2(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 function getString2(value) {
   return typeof value === "string" ? value : void 0;
 }
+var ExtensionInfo = class {
+  constructor(shape) {
+    this.id = shape.id;
+    this.name = shape.name;
+    this.projectId = shape.projectId;
+    this.createdAt = shape.createdAt;
+    this.updatedAt = shape.updatedAt;
+  }
+};
+var ExtensionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async upload(filePath, options = {}) {
+    const fileBuffer = await readFile(filePath);
+    const form = new FormData();
+    const usedProjectId = options.projectId ?? this.client.projectId;
+    form.append("project_id", usedProjectId);
+    if (options.name) {
+      form.append("name", options.name);
+    }
+    form.append(
+      "file",
+      new Blob([fileBuffer], { type: "application/octet-stream" }),
+      path.basename(filePath)
+    );
+    const response = await this.client._post(
+      `${this.client.baseUrl}/instance/v1/extension/upload`,
+      form,
+      {
+        headers: {
+          project_id: usedProjectId
+        }
+      }
+    );
+    if (response.status >= 400) {
+      this.handleError("upload extension", response);
+    }
+    getLogger().info(`Extension uploaded successfully: ${filePath}`);
+    return this.parseInfo(response.data);
+  }
+  async list(options = {}) {
+    const response = await this.client._post(`${this.client.baseUrl}/instance/v1/extension/list`, {
+      project_id: options.projectId ?? this.client.projectId,
+      limit: options.limit ?? 20,
+      offset: options.offset ?? 0
+    });
+    if (response.status >= 400) {
+      this.handleError("list extensions", response);
+    }
+    const result = asRecord2(response.data);
+    const items = Array.isArray(result.data) ? result.data : [];
+    return items.map((item) => this.parseInfo(item));
+  }
+  async get(extensionId, projectId) {
+    const response = await this.client._post(`${this.client.baseUrl}/instance/v1/extension/info`, {
+      project_id: projectId ?? this.client.projectId,
+      extension_id: extensionId
+    });
+    if (response.status >= 400) {
+      this.handleError("get extension", response);
+    }
+    return this.parseInfo(response.data);
+  }
+  async delete(extensionId) {
+    const response = await this.client._delete(
+      `${this.client.baseUrl}/instance/v1/extension/${extensionId}`
+    );
+    if (response.status >= 400) {
+      this.handleError("delete extension", response);
+    }
+    getLogger().info(`Extension deleted successfully: ${extensionId}`);
+  }
+  parseInfo(data) {
+    const item = asRecord2(data);
+    return new ExtensionInfo({
+      id: getString2(item.id) ?? "",
+      name: getString2(item.name) ?? "",
+      projectId: getString2(item.project_id) ?? "",
+      createdAt: getString2(item.created_at),
+      updatedAt: getString2(item.updated_at)
+    });
+  }
+  handleError(action, response) {
+    const errorData = asRecord2(response.data);
+    const errorMessage = getString2(errorData.message) ?? getString2(errorData.error) ?? "Unknown error";
+    if (response.status === 401) {
+      throw new AuthenticationError(
+        `Authentication failed: ${errorMessage}. Please check your API key and project ID.`
+      );
+    }
+    throw new APIError(`Failed to ${action}: ${errorMessage}`, {
+      statusCode: response.status,
+      response: response.data
+    });
+  }
+};
+
+// src/sessions.ts
+function asRecord3(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function getString3(value) {
+  return typeof value === "string" ? value : void 0;
+}
 function getNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
@@ -505,9 +612,134 @@ var SessionListResponse = class {
     return this.sessions[index];
   }
 };
+var SessionDownloadInfo = class {
+  constructor(shape) {
+    this.id = shape.id;
+    this.filename = shape.filename;
+    this.contentType = shape.contentType;
+    this.size = shape.size;
+    this.sha256 = shape.sha256;
+    this.status = shape.status;
+    this.createdAt = shape.createdAt;
+  }
+};
+var SessionDownloadsListResponse = class {
+  constructor(downloads, summary) {
+    this.downloads = downloads;
+    this.summary = summary;
+  }
+};
+var SessionDownloadsDeleteResponse = class {
+  constructor(shape) {
+    this.status = shape.status;
+    this.deletedCount = shape.deletedCount;
+  }
+};
+var SessionDownloadsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(sessionId, projectId) {
+    const response = await this.client._post(
+      `${this.client.baseUrl}/instance/v1/sessions/${sessionId}/downloads/list`,
+      {
+        api_key: this.client.apiKey,
+        project_id: projectId ?? this.client.projectId
+      }
+    );
+    if (response.status >= 400) {
+      this.handleError("list session downloads", response, sessionId);
+    }
+    const result = asRecord3(response.data);
+    const items = Array.isArray(result.downloads) ? result.downloads : [];
+    const downloads = items.map((item) => {
+      const download = asRecord3(item);
+      return new SessionDownloadInfo({
+        id: getString3(download.id) ?? "",
+        filename: getString3(download.filename) ?? "",
+        contentType: getString3(download.content_type) ?? null,
+        size: getNumber(download.size) ?? 0,
+        sha256: getString3(download.sha256) ?? null,
+        status: getString3(download.status) ?? "available",
+        createdAt: getString3(download.created_at) ?? ""
+      });
+    });
+    const summary = asRecord3(result.summary);
+    return new SessionDownloadsListResponse(downloads, {
+      count: getNumber(summary.count) ?? downloads.length,
+      totalSize: getNumber(summary.total_size) ?? 0
+    });
+  }
+  async get(sessionId, downloadId, projectId) {
+    const response = await this.client._get(
+      `${this.client.baseUrl}/instance/v1/sessions/${sessionId}/downloads/${downloadId}`,
+      {
+        api_key: this.client.apiKey,
+        project_id: projectId ?? this.client.projectId
+      },
+      {
+        responseType: "arraybuffer"
+      }
+    );
+    if (response.status >= 400) {
+      this.handleError("fetch session download", response, sessionId);
+    }
+    return Buffer.from(response.data);
+  }
+  async archive(sessionId, projectId) {
+    const response = await this.client._get(
+      `${this.client.baseUrl}/instance/v1/sessions/${sessionId}/downloads/archive`,
+      {
+        api_key: this.client.apiKey,
+        project_id: projectId ?? this.client.projectId
+      },
+      {
+        responseType: "arraybuffer"
+      }
+    );
+    if (response.status >= 400) {
+      this.handleError("archive session downloads", response, sessionId);
+    }
+    return Buffer.from(response.data);
+  }
+  async delete(sessionId, projectId) {
+    const response = await this.client._delete(
+      `${this.client.baseUrl}/instance/v1/sessions/${sessionId}/downloads`,
+      {
+        api_key: this.client.apiKey,
+        project_id: projectId ?? this.client.projectId
+      }
+    );
+    if (response.status >= 400) {
+      this.handleError("delete session downloads", response, sessionId);
+    }
+    const result = asRecord3(response.data);
+    return new SessionDownloadsDeleteResponse({
+      status: getString3(result.status) ?? "",
+      deletedCount: getNumber(result.deleted_count) ?? 0
+    });
+  }
+  handleError(action, response, sessionId) {
+    const errorData = asRecord3(response.data);
+    const errorMessage = getString3(errorData.error) ?? getString3(errorData.message) ?? "Unknown error";
+    if (response.status === 401) {
+      throw new AuthenticationError(
+        `Authentication failed: ${errorMessage}. Please check your API key and project ID.`
+      );
+    }
+    if (response.status === 404) {
+      throw new SessionNotFoundError(`Session downloads not found for ${sessionId}: ${errorMessage}`);
+    }
+    throw new APIError(`Failed to ${action}: ${errorMessage}`, {
+      statusCode: response.status,
+      response: response.data
+    });
+  }
+};
 var SessionsResource = class {
   constructor(client) {
     this.client = client;
+    this.downloads = new SessionDownloadsResource(client);
   }
   /**
    * Create a new browser session.
@@ -531,19 +763,25 @@ var SessionsResource = class {
     } else {
       getLogger().debug(`Creating session with browser_mode=${payload.browser_mode}`);
     }
+    if (options.extensionIds && options.extensionIds.length > 0) {
+      payload.extension_ids = options.extensionIds;
+    }
+    if (options.proxy) {
+      payload.proxy = this.normalizeProxy(options.proxy);
+    }
     const response = await this.client._post(url, payload);
     if (response.status >= 400) {
       this.handleCreateError(response);
     }
-    const result = asRecord2(response.data);
-    const sessionId = getString2(result.session_id);
+    const result = asRecord3(response.data);
+    const sessionId = getString3(result.session_id);
     if (!sessionId) {
       throw new APIError("Failed to create session: session_id missing from response", {
         statusCode: response.status,
         response: response.data
       });
     }
-    const containerId = getString2(result.container_id) ?? null;
+    const containerId = getString3(result.container_id) ?? null;
     const wsUrl = await this._getWebSocketDebuggerUrl(sessionId);
     const projectId = options.projectId ?? this.client.projectId;
     getLogger().info(`Session created successfully: id=${sessionId}, container_id=${containerId}`);
@@ -576,23 +814,23 @@ var SessionsResource = class {
     if (response.status >= 400) {
       this.handleListError(response);
     }
-    const result = asRecord2(response.data);
+    const result = asRecord3(response.data);
     const sessionsData = Array.isArray(result.sessions) ? result.sessions : [];
-    const paginationData = asRecord2(result.pagination);
+    const paginationData = asRecord3(result.pagination);
     const sessions = sessionsData.map((item) => {
-      const session = asRecord2(item);
-      const sessionId = getString2(session.id) ?? "";
+      const session = asRecord3(item);
+      const sessionId = getString3(session.id) ?? "";
       return new SessionInfo({
         id: sessionId,
-        status: getString2(session.status) ?? "active",
-        apiKey: getString2(session.api_key) ?? this.client.apiKey,
-        projectId: getString2(session.project_id) ?? (options.projectId ?? this.client.projectId),
-        browserType: getString2(session.browser_type) ?? "normal",
-        createdAt: getString2(session.created_at) ?? "",
-        inspectUrl: getString2(session.inspect_url) ?? `${this.client.baseUrl}/inspect?session_id=${sessionId}`,
-        containerId: getString2(session.container_id) ?? null,
-        inspectUrlDbg: getString2(session.inspect_url_dbg),
-        ws: getString2(session.ws) ?? null,
+        status: getString3(session.status) ?? "active",
+        apiKey: getString3(session.api_key) ?? this.client.apiKey,
+        projectId: getString3(session.project_id) ?? (options.projectId ?? this.client.projectId),
+        browserType: getString3(session.browser_type) ?? "normal",
+        createdAt: getString3(session.created_at) ?? "",
+        inspectUrl: getString3(session.inspect_url) ?? `${this.client.baseUrl}/inspect?session_id=${sessionId}`,
+        containerId: getString3(session.container_id) ?? null,
+        inspectUrlDbg: getString3(session.inspect_url_dbg),
+        ws: getString3(session.ws) ?? null,
         client: this.client
       });
     });
@@ -639,18 +877,34 @@ var SessionsResource = class {
         getLogger().error("Error getting WebSocket debugger URL:", response.data);
         return null;
       }
-      const result = asRecord2(response.data);
-      return getString2(result.webSocketDebuggerUrlTransformed) ?? getString2(result.webSocketDebuggerUrl) ?? null;
+      const result = asRecord3(response.data);
+      return getString3(result.webSocketDebuggerUrlTransformed) ?? getString3(result.webSocketDebuggerUrl) ?? null;
     } catch (error) {
       getLogger().error("Error getting WebSocket debugger URL:", error);
       return null;
     }
   }
+  normalizeProxy(proxy) {
+    if (!proxy.server) {
+      throw new ValidationError("proxy.server is required when proxy is provided");
+    }
+    const normalizedProxy = {
+      type: proxy.type ?? "external",
+      server: proxy.server
+    };
+    if (proxy.username) {
+      normalizedProxy.username = proxy.username;
+    }
+    if (proxy.password) {
+      normalizedProxy.password = proxy.password;
+    }
+    return normalizedProxy;
+  }
   handleCreateError(response) {
-    const errorData = asRecord2(response.data);
-    const errorMessage = getString2(errorData.error) ?? getString2(errorData.message) ?? "Unknown error";
-    const errorCode = getString2(errorData.code);
-    const metadata = asRecord2(errorData.metadata);
+    const errorData = asRecord3(response.data);
+    const errorMessage = getString3(errorData.error) ?? getString3(errorData.message) ?? "Unknown error";
+    const errorCode = getString3(errorData.code);
+    const metadata = asRecord3(errorData.metadata);
     if (response.status === 401) {
       throw new AuthenticationError(
         `Authentication failed: ${errorMessage}. Please check your API key and project ID.`
@@ -664,7 +918,7 @@ var SessionsResource = class {
     }
     if (response.status === 409 && errorCode === "context_locked") {
       throw new ContextLockedError(errorMessage, {
-        activeSessionId: getString2(metadata.activeSessionId),
+        activeSessionId: getString3(metadata.activeSessionId),
         retryAfter: getNumber(metadata.retryAfter)
       });
     }
@@ -674,8 +928,8 @@ var SessionsResource = class {
     });
   }
   handleListError(response) {
-    const errorData = asRecord2(response.data);
-    const errorMessage = getString2(errorData.error) ?? getString2(errorData.message) ?? "Unknown error";
+    const errorData = asRecord3(response.data);
+    const errorMessage = getString3(errorData.error) ?? getString3(errorData.message) ?? "Unknown error";
     if (response.status === 401) {
       throw new AuthenticationError(
         `Authentication failed: ${errorMessage}. Please check your API key and project ID.`
@@ -687,8 +941,8 @@ var SessionsResource = class {
     });
   }
   handleDeleteError(response, sessionId) {
-    const errorData = asRecord2(response.data);
-    const errorMessage = getString2(errorData.error) ?? getString2(errorData.message) ?? "Unknown error";
+    const errorData = asRecord3(response.data);
+    const errorMessage = getString3(errorData.error) ?? getString3(errorData.message) ?? "Unknown error";
     if (response.status === 401) {
       throw new AuthenticationError(
         `Authentication failed: ${errorMessage}. Please check your API key and project ID.`
@@ -728,37 +982,35 @@ var Lexmount = class {
     }
     this.httpClient = axios.create({
       timeout: config2.timeout ?? 6e4,
-      validateStatus: () => true,
-      headers: {
-        "Content-Type": "application/json"
-      }
+      validateStatus: () => true
     });
     this.sessions = new SessionsResource(this);
     this.contexts = new ContextsResource(this);
+    this.extensions = new ExtensionsResource(this);
   }
   /**
    * Internal POST request helper with timeout and network error mapping.
    *
    * @internal
    */
-  async _post(url, data) {
-    return this.request("POST", url, { data });
+  async _post(url, data, config2 = {}) {
+    return this.request("POST", url, { ...config2, data });
   }
   /**
    * Internal GET request helper with timeout and network error mapping.
    *
    * @internal
    */
-  async _get(url, params) {
-    return this.request("GET", url, { params });
+  async _get(url, params, config2 = {}) {
+    return this.request("GET", url, { ...config2, params });
   }
   /**
    * Internal DELETE request helper with timeout and network error mapping.
    *
    * @internal
    */
-  async _delete(url, data) {
-    return this.request("DELETE", url, { data });
+  async _delete(url, data, config2 = {}) {
+    return this.request("DELETE", url, { ...config2, data });
   }
   /**
    * Close the client.
@@ -779,10 +1031,17 @@ var Lexmount = class {
     const startTime = Date.now();
     logger2.debug(`${method} request to ${url}`);
     try {
+      const headers = {
+        api_key: this.apiKey,
+        project_id: this.projectId,
+        ...this.getDefaultHeaders(config2.data),
+        ...config2.headers ?? {}
+      };
       const response = await this.httpClient.request({
         method,
         url,
-        ...config2
+        ...config2,
+        headers
       });
       const elapsed = Date.now() - startTime;
       logger2.debug(`${method} response: status=${response.status}, duration=${elapsed.toFixed(2)}ms`);
@@ -813,6 +1072,17 @@ var Lexmount = class {
     logger2.error(`Network error after ${elapsedMs.toFixed(2)}ms:`, axiosError.message);
     return new NetworkError(`Network error: ${axiosError.message}`);
   }
+  getDefaultHeaders(data) {
+    if (typeof data === "undefined") {
+      return {};
+    }
+    if (typeof FormData !== "undefined" && data instanceof FormData) {
+      return {};
+    }
+    return {
+      "Content-Type": "application/json"
+    };
+  }
 };
 
 // src/index.ts
@@ -825,11 +1095,17 @@ export {
   ContextLockedError,
   ContextNotFoundError,
   ContextsResource,
+  ExtensionInfo,
+  ExtensionsResource,
   Lexmount,
   LexmountError,
   LexmountLogger,
   NetworkError,
   PaginationInfo,
+  SessionDownloadInfo,
+  SessionDownloadsDeleteResponse,
+  SessionDownloadsListResponse,
+  SessionDownloadsResource,
   SessionInfo,
   SessionListResponse,
   SessionNotFoundError,