@morphllm/morphsdk 0.2.92 → 0.2.94

package/dist/tools/browser/profiles/core.cjs

@@ -0,0 +1,639 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// tools/browser/profiles/core.ts
+var core_exports = {};
+__export(core_exports, {
+  ProfilesClient: () => ProfilesClient,
+  createProfile: () => createProfile,
+  deleteProfile: () => deleteProfile,
+  getProfile: () => getProfile,
+  getProfileState: () => getProfileState,
+  listProfiles: () => listProfiles,
+  saveProfileSession: () => saveProfileSession,
+  startProfileSession: () => startProfileSession,
+  updateProfile: () => updateProfile
+});
+module.exports = __toCommonJS(core_exports);
+
+// tools/utils/resilience.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  initialDelay: 1e3,
+  maxDelay: 3e4,
+  backoffMultiplier: 2,
+  retryableErrors: ["ECONNREFUSED", "ETIMEDOUT", "ENOTFOUND"]
+};
+async function fetchWithRetry(url, options, retryConfig = {}) {
+  const {
+    maxRetries = DEFAULT_RETRY_CONFIG.maxRetries,
+    initialDelay = DEFAULT_RETRY_CONFIG.initialDelay,
+    maxDelay = DEFAULT_RETRY_CONFIG.maxDelay,
+    backoffMultiplier = DEFAULT_RETRY_CONFIG.backoffMultiplier,
+    retryableErrors = DEFAULT_RETRY_CONFIG.retryableErrors,
+    onRetry
+  } = retryConfig;
+  let lastError = null;
+  let delay = initialDelay;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(url, options);
+      if (response.status === 429 || response.status === 503) {
+        if (attempt < maxRetries) {
+          const retryAfter = response.headers.get("Retry-After");
+          const waitTime = retryAfter ? parseInt(retryAfter) * 1e3 : Math.min(delay, maxDelay);
+          const error = new Error(`HTTP ${response.status}: Retrying after ${waitTime}ms`);
+          if (onRetry) {
+            onRetry(attempt + 1, error);
+          }
+          await sleep(waitTime);
+          delay *= backoffMultiplier;
+          continue;
+        }
+      }
+      return response;
+    } catch (error) {
+      lastError = error;
+      const isRetryable = retryableErrors.some(
+        (errType) => lastError?.message?.includes(errType)
+      );
+      if (!isRetryable || attempt === maxRetries) {
+        throw lastError;
+      }
+      const waitTime = Math.min(delay, maxDelay);
+      if (onRetry) {
+        onRetry(attempt + 1, lastError);
+      }
+      await sleep(waitTime);
+      delay *= backoffMultiplier;
+    }
+  }
+  throw lastError || new Error("Max retries exceeded");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// tools/browser/errors.ts
+var MorphError = class extends Error {
+  /** Error code for programmatic handling */
+  code;
+  /** Original cause of the error, if any */
+  cause;
+  constructor(message, code, cause) {
+    super(message);
+    this.name = "MorphError";
+    this.code = code;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Returns a JSON representation of the error for logging.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      cause: this.cause?.message
+    };
+  }
+};
+var MorphValidationError = class extends MorphError {
+  /** The field that failed validation */
+  field;
+  constructor(message, field) {
+    super(message, "validation_error");
+    this.name = "MorphValidationError";
+    this.field = field;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      field: this.field
+    };
+  }
+};
+var MorphAPIError = class extends MorphError {
+  /** HTTP status code */
+  statusCode;
+  /** Request ID for debugging (if available) */
+  requestId;
+  /** Raw response body */
+  rawResponse;
+  constructor(message, code, statusCode, options) {
+    super(message, code, options?.cause);
+    this.name = "MorphAPIError";
+    this.statusCode = statusCode;
+    this.requestId = options?.requestId;
+    this.rawResponse = options?.rawResponse;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      statusCode: this.statusCode,
+      requestId: this.requestId
+    };
+  }
+};
+var MorphAuthenticationError = class extends MorphAPIError {
+  constructor(message = "Authentication required. Please provide a valid API key.") {
+    super(message, "authentication_required", 401);
+    this.name = "MorphAuthenticationError";
+  }
+};
+var MorphRateLimitError = class extends MorphAPIError {
+  /** When the rate limit resets (Unix timestamp) */
+  resetAt;
+  /** Number of seconds until reset */
+  retryAfter;
+  constructor(message = "Rate limit exceeded. Please retry later.", options) {
+    super(message, "rate_limit_exceeded", 429, { requestId: options?.requestId });
+    this.name = "MorphRateLimitError";
+    this.resetAt = options?.resetAt;
+    this.retryAfter = options?.retryAfter;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      resetAt: this.resetAt,
+      retryAfter: this.retryAfter
+    };
+  }
+};
+var MorphNotFoundError = class extends MorphAPIError {
+  /** The type of resource that was not found */
+  resourceType;
+  /** The ID of the resource that was not found */
+  resourceId;
+  constructor(resourceType, resourceId) {
+    const message = resourceId ? `${resourceType} '${resourceId}' not found` : `${resourceType} not found`;
+    super(message, "resource_not_found", 404);
+    this.name = "MorphNotFoundError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      resourceType: this.resourceType,
+      resourceId: this.resourceId
+    };
+  }
+};
+var MorphProfileLimitError = class extends MorphAPIError {
+  /** Current number of profiles */
+  currentCount;
+  /** Maximum allowed profiles for the plan */
+  maxAllowed;
+  constructor(message = "Profile limit exceeded for your plan.", options) {
+    super(message, "profile_limit_exceeded", 403, { requestId: options?.requestId });
+    this.name = "MorphProfileLimitError";
+    this.currentCount = options?.currentCount;
+    this.maxAllowed = options?.maxAllowed;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      currentCount: this.currentCount,
+      maxAllowed: this.maxAllowed
+    };
+  }
+};
+function parseAPIError(statusCode, responseText, requestId) {
+  let errorData = {};
+  try {
+    errorData = JSON.parse(responseText);
+  } catch {
+  }
+  const message = errorData.detail || errorData.message || responseText || "Unknown error";
+  const code = errorData.code;
+  switch (statusCode) {
+    case 401:
+      return new MorphAuthenticationError(message);
+    case 403:
+      if (code === "profile_limit_exceeded" || message.toLowerCase().includes("limit")) {
+        return new MorphProfileLimitError(message, { requestId });
+      }
+      return new MorphAPIError(message, "insufficient_permissions", statusCode, { requestId, rawResponse: responseText });
+    case 404:
+      if (message.toLowerCase().includes("profile")) {
+        return new MorphNotFoundError("Profile", void 0);
+      }
+      if (message.toLowerCase().includes("session")) {
+        return new MorphNotFoundError("Session", void 0);
+      }
+      return new MorphAPIError(message, "resource_not_found", statusCode, { requestId, rawResponse: responseText });
+    case 429:
+      return new MorphRateLimitError(message, { requestId });
+    case 422:
+      return new MorphAPIError(message, "validation_error", statusCode, { requestId, rawResponse: responseText });
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      return new MorphAPIError(message, "service_unavailable", statusCode, { requestId, rawResponse: responseText });
+    default:
+      return new MorphAPIError(message, "network_error", statusCode, { requestId, rawResponse: responseText });
+  }
+}
+
+// tools/browser/profiles/types.ts
+function transformProfile(api) {
+  return {
+    id: api.id,
+    name: api.name,
+    repoId: api.repo_id,
+    cookieDomains: api.cookie_domains,
+    lastUsedAt: api.last_used_at,
+    createdAt: api.created_at,
+    updatedAt: api.updated_at
+  };
+}
+function transformCreateInput(input) {
+  return {
+    name: input.name,
+    repo_id: input.repoId
+  };
+}
+function transformSession(api) {
+  return {
+    sessionId: api.session_id,
+    debugUrl: api.debug_url || api.debugUrl || ""
+  };
+}
+function transformSaveInput(input) {
+  return {
+    session_id: input.sessionId,
+    profile_id: input.profileId
+  };
+}
+function transformStateResponse(api) {
+  return {
+    profileId: api.profile_id,
+    stateUrl: api.state_url,
+    expiresIn: api.expires_in
+  };
+}
+
+// tools/browser/profiles/core.ts
+var DEFAULT_API_URL = process.env.MORPH_ENVIRONMENT === "DEV" ? "http://localhost:8000" : "https://browser.morphllm.com";
+var ProfilesClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create a new browser profile.
+   *
+   * @param input - Profile creation parameters
+   * @returns The created profile
+   * @throws {MorphValidationError} If input validation fails
+   * @throws {MorphProfileLimitError} If profile limit is exceeded
+   * @throws {MorphAuthenticationError} If API key is missing or invalid
+   *
+   * @example
+   * ```typescript
+   * const profile = await morph.browser.profiles.createProfile({
+   *   name: 'LinkedIn Production',
+   *   repoId: 'repo-uuid-here'
+   * });
+   * ```
+   */
+  async createProfile(input) {
+    return createProfile(input, this.config);
+  }
+  /**
+   * List all profiles for the authenticated user.
+   *
+   * @param repoId - Optional repository ID to filter by
+   * @returns Array of profiles
+   *
+   * @example
+   * ```typescript
+   * // List all profiles
+   * const allProfiles = await morph.browser.profiles.listProfiles();
+   *
+   * // List profiles for a specific repo
+   * const repoProfiles = await morph.browser.profiles.listProfiles('repo-uuid');
+   * ```
+   */
+  async listProfiles(repoId) {
+    return listProfiles(this.config, repoId);
+  }
+  /**
+   * Get a profile by ID with convenience methods.
+   *
+   * @param id - Profile ID
+   * @returns Profile with attached methods
+   * @throws {MorphNotFoundError} If profile is not found
+   *
+   * @example
+   * ```typescript
+   * const profile = await morph.browser.profiles.getProfile('profile-id');
+   * const state = await profile.getState();
+   * await profile.delete();
+   * ```
+   */
+  async getProfile(id) {
+    return getProfile(id, this.config);
+  }
+  /**
+   * Update a profile's name.
+   *
+   * @param id - Profile ID
+   * @param input - Update parameters
+   * @returns Updated profile
+   */
+  async updateProfile(id, input) {
+    return updateProfile(id, input, this.config);
+  }
+  /**
+   * Delete a profile.
+   *
+   * @param id - Profile ID
+   * @throws {MorphNotFoundError} If profile is not found
+   */
+  async deleteProfile(id) {
+    return deleteProfile(id, this.config);
+  }
+  /**
+   * Start a browser session for profile setup.
+   *
+   * Returns a live URL where the user can sign into accounts.
+   * After signing in, call `saveSession` to persist the state.
+   *
+   * @param input - Optional session parameters
+   * @returns Session with debug URL
+   *
+   * @example
+   * ```typescript
+   * const session = await morph.browser.profiles.startSession();
+   * console.log('Sign in at:', session.debugUrl);
+   * // Open debugUrl in browser, user signs in...
+   * await morph.browser.profiles.saveSession(session.sessionId, profile.id);
+   * ```
+   */
+  async startSession(input) {
+    return startProfileSession(this.config, input);
+  }
+  /**
+   * Save browser state from a session to a profile.
+   *
+   * Call this after the user is done signing into accounts.
+   * Extracts cookies, localStorage, and sessionStorage.
+   *
+   * @param sessionId - Browser session ID from startSession
+   * @param profileId - Profile ID to save state to
+   * @returns Updated profile with cookie domains
+   */
+  async saveSession(sessionId, profileId) {
+    return saveProfileSession({ sessionId, profileId }, this.config);
+  }
+  /**
+   * Get the presigned URL for a profile's state.
+   *
+   * Use this to download the raw state JSON for debugging
+   * or to restore state manually.
+   *
+   * @param profileId - Profile ID
+   * @returns State URL with expiry information
+   */
+  async getProfileState(profileId) {
+    return getProfileState(profileId, this.config);
+  }
+};
+function validateCreateInput(input) {
+  if (!input.name || typeof input.name !== "string") {
+    throw new MorphValidationError("name is required", "name");
+  }
+  const trimmedName = input.name.trim();
+  if (trimmedName.length === 0) {
+    throw new MorphValidationError("name cannot be empty", "name");
+  }
+  if (trimmedName.length > 100) {
+    throw new MorphValidationError("name must be 100 characters or less", "name");
+  }
+  if (!input.repoId || typeof input.repoId !== "string") {
+    throw new MorphValidationError("repoId is required", "repoId");
+  }
+  if (input.repoId.trim().length === 0) {
+    throw new MorphValidationError("repoId cannot be empty", "repoId");
+  }
+}
+function validateId(id, fieldName) {
+  if (!id || typeof id !== "string") {
+    throw new MorphValidationError(`${fieldName} is required`, fieldName);
+  }
+  if (id.trim().length === 0) {
+    throw new MorphValidationError(`${fieldName} cannot be empty`, fieldName);
+  }
+}
+async function createProfile(input, config = {}) {
+  validateCreateInput(input);
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(transformCreateInput(input))
+    },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const apiProfile = await response.json();
+  return transformProfile(apiProfile);
+}
+async function listProfiles(config = {}, repoId) {
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const url = repoId ? `${apiUrl}/profiles?repo_id=${encodeURIComponent(repoId)}` : `${apiUrl}/profiles`;
+  const response = await fetchWithRetry(
+    url,
+    { method: "GET", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const data = await response.json();
+  return data.profiles.map(transformProfile);
+}
+async function getProfile(id, config = {}) {
+  validateId(id, "id");
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/${encodeURIComponent(id)}`,
+    { method: "GET", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const apiProfile = await response.json();
+  const profile = transformProfile(apiProfile);
+  return {
+    ...profile,
+    getState: () => getProfileState(id, config),
+    delete: () => deleteProfile(id, config)
+  };
+}
+async function updateProfile(id, input, config = {}) {
+  validateId(id, "id");
+  if (input.name !== void 0) {
+    if (typeof input.name !== "string") {
+      throw new MorphValidationError("name must be a string", "name");
+    }
+    if (input.name.trim().length === 0) {
+      throw new MorphValidationError("name cannot be empty", "name");
+    }
+    if (input.name.length > 100) {
+      throw new MorphValidationError("name must be 100 characters or less", "name");
+    }
+  }
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/${encodeURIComponent(id)}`,
+    {
+      method: "PATCH",
+      headers,
+      body: JSON.stringify(input)
+    },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const apiProfile = await response.json();
+  return transformProfile(apiProfile);
+}
+async function deleteProfile(id, config = {}) {
+  validateId(id, "id");
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/${encodeURIComponent(id)}`,
+    { method: "DELETE", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+}
+async function startProfileSession(config = {}, input) {
+  if (!config.apiKey) {
+    throw new MorphAuthenticationError();
+  }
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const body = input?.profileId ? { profile_id: input.profileId } : {};
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/session/start`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const apiSession = await response.json();
+  return transformSession(apiSession);
+}
+async function saveProfileSession(input, config = {}) {
+  validateId(input.sessionId, "sessionId");
+  validateId(input.profileId, "profileId");
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/session/save`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(transformSaveInput(input))
+    },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const apiProfile = await response.json();
+  return transformProfile(apiProfile);
+}
+async function getProfileState(profileId, config = {}) {
+  validateId(profileId, "profileId");
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/${encodeURIComponent(profileId)}/state`,
+    { method: "GET", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const apiState = await response.json();
+  return transformStateResponse(apiState);
+}
+function buildHeaders(config) {
+  const headers = { "Content-Type": "application/json" };
+  if (config.apiKey) {
+    headers["Authorization"] = `Bearer ${config.apiKey}`;
+  }
+  return headers;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProfilesClient,
+  createProfile,
+  deleteProfile,
+  getProfile,
+  getProfileState,
+  listProfiles,
+  saveProfileSession,
+  startProfileSession,
+  updateProfile
+});
+//# sourceMappingURL=core.cjs.map