@omnikit-ai/sdk 2.0.9 → 2.2.0

package/dist/index.js

@@ -435,6 +435,53 @@ var LiveVoiceSessionImpl = class {
   }
 };
 
+// src/connectors.ts
+function createConnectorsModule(makeRequest, appId, baseUrl, getServiceToken) {
+  return {
+    async getAccessToken(connectorType) {
+      const serviceToken = getServiceToken();
+      if (!serviceToken) {
+        throw new Error(
+          "Service token is required to get connector access token. This method is only available in backend functions. Make sure you created the client with a serviceToken."
+        );
+      }
+      return makeRequest(
+        `${baseUrl}/apps/${appId}/connectors/${connectorType}/access-token`,
+        "GET",
+        null,
+        { useServiceToken: true }
+      );
+    },
+    async isConnected(connectorType) {
+      try {
+        const response = await makeRequest(
+          `${baseUrl}/apps/${appId}/connectors/${connectorType}`,
+          "GET"
+        );
+        return response?.connector?.status === "connected";
+      } catch {
+        return false;
+      }
+    },
+    async getStatus(connectorType) {
+      try {
+        const response = await makeRequest(
+          `${baseUrl}/apps/${appId}/connectors/${connectorType}`,
+          "GET"
+        );
+        return {
+          success: true,
+          connector: response?.connector
+        };
+      } catch (error) {
+        return {
+          success: false
+        };
+      }
+    }
+  };
+}
+
 // src/client.ts
 var LLM_MODEL_MAP = {
   // Gemini 2.5 models
@@ -529,10 +576,96 @@ var APIClient = class {
         this.userToken = detectedToken;
       }
     }
+    this.initializeBuiltInServices();
     this.ensureInitialized().catch((err) => {
       console.warn("[Omnikit SDK] Background initialization failed:", err);
     });
   }
+  /**
+   * Initialize built-in services with their definitions
+   * These services don't require backend schema - they're defined in the SDK
+   */
+  initializeBuiltInServices() {
+    const builtInServices = [
+      {
+        name: "SendEmail",
+        path: "/services/email",
+        description: "Send an email",
+        method: "POST",
+        params: { to: "string", subject: "string", body: "string" }
+      },
+      {
+        name: "InvokeLLM",
+        path: "/services/llm",
+        description: "Invoke a language model",
+        method: "POST",
+        params: { messages: "array", model: "string" }
+      },
+      {
+        name: "GenerateImage",
+        path: "/services/images",
+        description: "Generate an image from a prompt",
+        method: "POST",
+        async: true,
+        params: { prompt: "string" }
+      },
+      {
+        name: "GenerateSpeech",
+        path: "/services/speech",
+        description: "Generate speech from text",
+        method: "POST",
+        async: true,
+        params: { text: "string" }
+      },
+      {
+        name: "GenerateVideo",
+        path: "/services/video",
+        description: "Generate a video from a prompt",
+        method: "POST",
+        async: true,
+        params: { prompt: "string" }
+      },
+      {
+        name: "ExtractData",
+        path: "/services/extract-text",
+        description: "Extract structured data from text or files",
+        method: "POST",
+        async: true,
+        params: { file_url: "string" }
+      },
+      {
+        name: "SendSMS",
+        path: "/services/sms",
+        description: "Send an SMS message",
+        method: "POST",
+        params: { to: "string", body: "string" }
+      },
+      {
+        name: "UploadFile",
+        path: "/services/files",
+        description: "Upload a file (public)",
+        method: "POST",
+        params: { file: "File" }
+      },
+      {
+        name: "UploadPrivateFile",
+        path: "/services/files/private",
+        description: "Upload a private file",
+        method: "POST",
+        params: { file: "File" }
+      },
+      {
+        name: "CreateFileSignedUrl",
+        path: "/services/files/signed-url",
+        description: "Create a signed URL for a private file",
+        method: "POST",
+        params: { file_uri: "string" }
+      }
+    ];
+    builtInServices.forEach((service) => {
+      this._services[service.name] = this.createServiceMethod(service);
+    });
+  }
   /**
    * Load metadata from localStorage cache, falling back to initial config
    * Guards localStorage access for Deno/Node compatibility
@@ -672,13 +805,13 @@ var APIClient = class {
     return this.createAuthProxy();
   }
   /**
-   * Lazy getter for service role operations
-   * Only available when serviceToken is provided
+   * Service-level operations (elevated privileges).
+   * Only available when serviceToken is provided (e.g., via createServerClient).
    */
-  get asServiceRole() {
+  get service() {
     if (!this._serviceToken) {
       throw new OmnikitError(
-        "Service token is required to use asServiceRole. Provide serviceToken in config.",
+        "Service token is required. Use createServerClient(req) in backend functions.",
         403,
         "SERVICE_TOKEN_REQUIRED"
       );
@@ -691,12 +824,51 @@ var APIClient = class {
       // Service role collections
       services: this.createServicesProxy(true),
       // Service role services (new flat structure)
-      integrations: this.createIntegrationsProxy(true)
+      integrations: this.createIntegrationsProxy(true),
       // Service role integrations (legacy)
+      connectors: this.connectors
+      // Connectors module (requires service token)
       // Note: auth not available in service role for security
     };
     return this._asServiceRole;
   }
+  /**
+   * @deprecated Use service instead
+   */
+  get asServiceRole() {
+    return this.service;
+  }
+  /**
+   * Lazy getter for connectors module
+   * Like Base44's connectors - provides access to external service tokens
+   *
+   * SECURITY: getAccessToken requires service token authentication.
+   * Only use in backend functions, not frontend code.
+   *
+   * @example
+   * ```typescript
+   * // In a backend function
+   * const { access_token } = await omnikit.connectors.getAccessToken('slack');
+   *
+   * // Make direct Slack API call
+   * const response = await fetch('https://slack.com/api/chat.postMessage', {
+   *   method: 'POST',
+   *   headers: { Authorization: `Bearer ${access_token}` },
+   *   body: JSON.stringify({ channel: '#general', text: 'Hello!' })
+   * });
+   * ```
+   */
+  get connectors() {
+    if (!this._connectors) {
+      this._connectors = createConnectorsModule(
+        this.makeRequest.bind(this),
+        this.appId,
+        this.baseUrl,
+        () => this._serviceToken
+      );
+    }
+    return this._connectors;
+  }
   /**
    * Create auth proxy that auto-initializes
    */
@@ -1191,57 +1363,11 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
             if (method) {
               response = await method(params, useServiceToken);
             } else {
-              const servicePathMap = {
-                "SendEmail": "services/email",
-                "InvokeLLM": "services/llm",
-                "GenerateImage": "services/images",
-                "GenerateSpeech": "services/speech",
-                "GenerateVideo": "services/video",
-                "ExtractData": "services/extract-text",
-                "SendSMS": "services/sms",
-                "UploadFile": "services/files",
-                "UploadPrivateFile": "services/files/private/init",
-                "CreateFileSignedUrl": "services/files/signed-url"
-              };
-              const servicePath = servicePathMap[normalizedName];
-              if (!servicePath) {
-                throw new OmnikitError(
-                  `Service '${serviceName}' not found. Known services: ${Object.keys(servicePathMap).join(", ")} (camelCase also supported)`,
-                  404,
-                  "SERVICE_NOT_FOUND"
-                );
-              }
-              const headers = {
-                "Content-Type": "application/json"
-              };
-              if (client._apiKey) {
-                headers["X-API-Key"] = client._apiKey;
-              } else if (client.userToken) {
-                headers["Authorization"] = `Bearer ${client.userToken}`;
-              }
-              if ((normalizedName === "UploadFile" || normalizedName === "uploadFile") && params?.file instanceof File) {
-                return client.handleFileUpload(params.file, servicePath, useServiceToken);
-              }
-              if ((normalizedName === "UploadPrivateFile" || normalizedName === "uploadPrivateFile") && params?.file instanceof File) {
-                return client.handleFileUpload(params.file, servicePath, useServiceToken);
-              }
-              const fetchResponse = await fetch(
-                `${client.baseUrl}/apps/${client.appId}/${servicePath}`,
-                {
-                  method: "POST",
-                  headers,
-                  body: JSON.stringify(params || {})
-                }
+              throw new OmnikitError(
+                `Service '${serviceName}' not found. Known services: SendEmail, InvokeLLM, GenerateImage, GenerateSpeech, GenerateVideo, ExtractData, SendSMS, UploadFile, UploadPrivateFile, CreateFileSignedUrl (camelCase also supported)`,
+                404,
+                "SERVICE_NOT_FOUND"
               );
-              if (!fetchResponse.ok) {
-                const error = await fetchResponse.json().catch(() => ({}));
-                throw new OmnikitError(
-                  error.detail || `Service call failed: ${fetchResponse.statusText}`,
-                  fetchResponse.status,
-                  "SERVICE_CALL_FAILED"
-                );
-              }
-              response = await fetchResponse.json();
             }
             if (response && response.async && response.job_id) {
               if (asyncOptions?.returnJobId) {
@@ -2196,12 +2322,298 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
 function createClient(config) {
   return new APIClient(config);
 }
+function createServerClient(request) {
+  const getHeader = (name) => {
+    if (typeof request.headers.get === "function") {
+      return request.headers.get(name);
+    }
+    return request.headers[name] || request.headers[name.toLowerCase()] || null;
+  };
+  const authHeader = getHeader("Authorization") || getHeader("authorization");
+  const userToken = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+  const serviceToken = getHeader("X-Omnikit-Service-Authorization") || getHeader("x-omnikit-service-authorization");
+  const appId = getHeader("X-Omnikit-App-Id") || getHeader("x-omnikit-app-id");
+  const serverUrl = getHeader("X-Omnikit-Server-Url") || getHeader("x-omnikit-server-url") || "https://omnikit.ai/api";
+  if (!appId) {
+    throw new OmnikitError(
+      "X-Omnikit-App-Id header is required. This function should be invoked through the Omnikit platform.",
+      400,
+      "MISSING_APP_ID"
+    );
+  }
+  return createClient({
+    appId,
+    serverUrl,
+    token: userToken || void 0,
+    serviceToken: serviceToken || void 0,
+    autoInitAuth: false
+    // Don't auto-detect from localStorage in backend
+  });
+}
+var createClientFromRequest = createServerClient;
+
+// src/analytics.ts
+var STORAGE_KEY = "omnikit_session";
+var SESSION_TIMEOUT = 30 * 60 * 1e3;
+var FLUSH_INTERVAL = 5e3;
+var MAX_RETRIES = 3;
+var Analytics = class {
+  constructor(config) {
+    this.eventQueue = [];
+    this.config = config;
+    this.enabled = config.enabled !== false;
+    this.sessionId = config.sessionId || this.initSession();
+    this.userId = config.userId;
+    if (this.enabled && typeof window !== "undefined") {
+      this.startFlushTimer();
+      window.addEventListener("beforeunload", () => this.flush());
+      window.addEventListener("pagehide", () => this.flush());
+    }
+  }
+  // ==========================================================================
+  // Session Management
+  // ==========================================================================
+  initSession() {
+    if (typeof window === "undefined" || typeof localStorage === "undefined") {
+      return this.generateId();
+    }
+    try {
+      const stored = localStorage.getItem(STORAGE_KEY);
+      if (stored) {
+        const { id, timestamp } = JSON.parse(stored);
+        if (Date.now() - timestamp < SESSION_TIMEOUT) {
+          localStorage.setItem(STORAGE_KEY, JSON.stringify({
+            id,
+            timestamp: Date.now()
+          }));
+          return id;
+        }
+      }
+    } catch {
+    }
+    const newId = this.generateId();
+    this.saveSession(newId);
+    return newId;
+  }
+  generateId() {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  saveSession(id) {
+    if (typeof localStorage === "undefined") return;
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify({
+        id,
+        timestamp: Date.now()
+      }));
+    } catch {
+    }
+  }
+  /**
+   * Get the current session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Start a new session (e.g., after logout)
+   */
+  startNewSession() {
+    this.sessionId = this.generateId();
+    this.saveSession(this.sessionId);
+    return this.sessionId;
+  }
+  // ==========================================================================
+  // User Identification
+  // ==========================================================================
+  /**
+   * Associate events with a user ID
+   */
+  setUserId(userId) {
+    this.userId = userId;
+  }
+  /**
+   * Clear user association (e.g., on logout)
+   */
+  clearUserId() {
+    this.userId = void 0;
+  }
+  // ==========================================================================
+  // Core Logging Methods
+  // ==========================================================================
+  /**
+   * Log a custom event
+   */
+  async logEvent(eventType, payload = {}) {
+    if (!this.enabled) return;
+    this.eventQueue.push({
+      eventType,
+      payload,
+      timestamp: Date.now()
+    });
+    if (eventType === "error" || eventType === "api_error") {
+      await this.flush();
+    }
+  }
+  /**
+   * Log a page view event
+   */
+  async logPageView(pageName, metadata) {
+    if (!this.enabled) return;
+    const url = typeof window !== "undefined" ? window.location.href : "";
+    const referrer = typeof document !== "undefined" ? document.referrer : "";
+    await this.logEvent("page_view", {
+      page_name: pageName,
+      metadata: {
+        url,
+        referrer,
+        ...metadata
+      }
+    });
+  }
+  /**
+   * Log an error event
+   */
+  async logError(error, componentStack) {
+    if (!this.enabled) return;
+    const url = typeof window !== "undefined" ? window.location.href : "";
+    await this.logEvent("error", {
+      error_message: error.message,
+      error_stack: error.stack,
+      metadata: {
+        name: error.name,
+        component_stack: componentStack,
+        url
+      }
+    });
+  }
+  /**
+   * Log an API error event
+   */
+  async logApiError(endpoint, statusCode, errorMessage, metadata) {
+    if (!this.enabled) return;
+    await this.logEvent("api_error", {
+      error_message: errorMessage,
+      metadata: {
+        endpoint,
+        status_code: statusCode,
+        ...metadata
+      }
+    });
+  }
+  // ==========================================================================
+  // Event Batching & Flushing
+  // ==========================================================================
+  startFlushTimer() {
+    if (this.flushTimer) return;
+    this.flushTimer = setInterval(() => {
+      if (this.eventQueue.length > 0) {
+        this.flush();
+      }
+    }, FLUSH_INTERVAL);
+  }
+  /**
+   * Flush all queued events to the server
+   */
+  async flush() {
+    if (this.eventQueue.length === 0) return;
+    const events = [...this.eventQueue];
+    this.eventQueue = [];
+    const sendPromises = events.map(
+      ({ eventType, payload }) => this.sendEvent(eventType, payload)
+    );
+    await Promise.allSettled(sendPromises);
+  }
+  async sendEvent(eventType, payload) {
+    const pageName = payload.page_name || (typeof window !== "undefined" ? window.location.pathname : "/");
+    const url = `${this.config.apiUrl}/api/app-logs/${this.config.appId}/log-event`;
+    const body = {
+      session_id: this.sessionId,
+      user_id: this.userId,
+      event_type: eventType,
+      page_name: pageName,
+      action: payload.action,
+      inputs: payload.inputs,
+      metadata: payload.metadata,
+      is_error: eventType === "error" || eventType === "api_error",
+      error_message: payload.error_message,
+      error_stack: payload.error_stack
+    };
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          keepalive: true
+          // Ensures request completes even on page unload
+        });
+        if (response.ok) {
+          return;
+        }
+        if (response.status >= 400 && response.status < 500) {
+          console.warn(`[Omnikit Analytics] Event rejected: ${response.status}`);
+          return;
+        }
+      } catch (err) {
+      }
+      if (attempt < MAX_RETRIES - 1) {
+        await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1e3));
+      }
+    }
+    console.warn("[Omnikit Analytics] Failed to send event after retries");
+  }
+  // ==========================================================================
+  // Lifecycle
+  // ==========================================================================
+  /**
+   * Enable or disable analytics
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+    if (enabled && typeof window !== "undefined") {
+      this.startFlushTimer();
+    } else if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = void 0;
+    }
+  }
+  /**
+   * Check if analytics is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Clean up resources
+   */
+  destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = void 0;
+    }
+    this.flush();
+  }
+};
+function createAnalytics(config) {
+  return new Analytics(config);
+}
 
 exports.APIClient = APIClient;
+exports.Analytics = Analytics;
 exports.LiveVoiceSessionImpl = LiveVoiceSessionImpl;
 exports.OmnikitError = OmnikitError;
 exports.cleanTokenFromUrl = cleanTokenFromUrl;
+exports.createAnalytics = createAnalytics;
 exports.createClient = createClient;
+exports.createClientFromRequest = createClientFromRequest;
+exports.createServerClient = createServerClient;
 exports.getAccessToken = getAccessToken;
 exports.isTokenInUrl = isTokenInUrl;
 exports.removeAccessToken = removeAccessToken;