opencloud-platform-sdk 1.3.0 → 2.0.0

package/dist/index.mjs

@@ -1,64 +1,30 @@
 // src/index.ts
 var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
-var STORAGE_KEYS = {
-  OPENROUTER_KEY: "openrouter_api_key",
-  ANTHROPIC_KEY: "anthropic_api_key",
-  OPENAI_KEY: "openai_api_key",
-  PREVIEW_PROVIDER: "opencloud_preview_provider"
-};
-function getCookie(name) {
-  if (!isBrowser) return null;
-  const value = `; ${document.cookie}`;
-  const parts = value.split(`; ${name}=`);
-  if (parts.length === 2) {
-    const cookieValue = parts.pop()?.split(";").shift();
-    if (cookieValue) {
-      try {
-        return decodeURIComponent(cookieValue);
-      } catch {
-        return cookieValue;
-      }
-    }
-  }
-  return null;
-}
-function getBoltApiKeys() {
-  const apiKeysCookie = getCookie("apiKeys");
-  if (!apiKeysCookie) return null;
-  try {
-    return JSON.parse(apiKeysCookie);
-  } catch {
-    return null;
-  }
-}
 var OpenCloudSDK = class {
   constructor() {
     this._isPreviewMode = false;
+    this._cachedSession = null;
     this.config = {
       appId: "",
-      apiUrl: isBrowser ? window.location.origin : "http://localhost:3000",
-      previewApiKey: void 0
+      apiUrl: isBrowser ? window.location.origin : "https://opencloud.app"
     };
     if (isBrowser) {
       this._isPreviewMode = this.detectPreviewMode();
     }
   }
-  /**
-   * Detect if running in preview/development mode
-   */
   detectPreviewMode() {
     if (!isBrowser) return false;
     const hostname = window.location.hostname;
     return hostname.includes("webcontainer") || hostname.includes("localhost") || hostname.includes("127.0.0.1") || hostname.includes(".local") || hostname.includes("stackblitz") || hostname.includes("codesandbox");
   }
   /**
-   * Check if currently in preview mode
+   * Check if running in preview/development mode
    */
   isPreview() {
     return this._isPreviewMode;
   }
   /**
-   * Initialize the SDK
+   * Initialize the SDK with your app ID
    */
   init(options) {
     if (!options.appId) {
@@ -66,8 +32,7 @@ var OpenCloudSDK = class {
     }
     this.config = {
       appId: options.appId,
-      apiUrl: options.apiUrl || this.config.apiUrl,
-      previewApiKey: options.previewApiKey
+      apiUrl: options.apiUrl || this.config.apiUrl
     };
     if (!this._isPreviewMode) {
       this.startHeartbeat();
@@ -76,235 +41,105 @@ var OpenCloudSDK = class {
     console.log(`[OpenCloudSDK] Initialized for app: ${options.appId} (${mode} mode)`);
   }
   /**
-   * Set API key for preview mode
-   * Safe to call during build - will be a no-op if not in browser
+   * Track a usage event and charge the user
+   * Call this BEFORE or AFTER your AI/API call
+   *
+   * Example:
+   * ```
+   * // Check if user can afford it first
+   * const canUse = await opencloud.canAfford();
+   * if (!canUse) {
+   *   opencloud.requestTopUp();
+   *   return;
+   * }
+   *
+   * // Do your AI call
+   * const result = await myAICall();
+   *
+   * // Track the usage (charges user)
+   * await opencloud.trackUsage({ action: 'chat_message' });
+   * ```
    */
-  setPreviewApiKey(key, provider = "openrouter") {
-    if (!isBrowser) return;
-    const storageKey = provider === "openrouter" ? STORAGE_KEYS.OPENROUTER_KEY : provider === "anthropic" ? STORAGE_KEYS.ANTHROPIC_KEY : STORAGE_KEYS.OPENAI_KEY;
-    localStorage.setItem(storageKey, key);
-    localStorage.setItem(STORAGE_KEYS.PREVIEW_PROVIDER, provider);
-    this.config.previewApiKey = key;
-  }
-  /**
-   * Get API key for preview mode
-   * Checks in order: config, localStorage, bolt.diy cookies
-   */
-  getPreviewApiKey() {
-    if (!isBrowser) return null;
-    if (this.config.previewApiKey) {
-      return { key: this.config.previewApiKey, provider: "openrouter" };
-    }
-    const provider = localStorage.getItem(STORAGE_KEYS.PREVIEW_PROVIDER) || "openrouter";
-    const storageKey = provider === "openrouter" ? STORAGE_KEYS.OPENROUTER_KEY : provider === "anthropic" ? STORAGE_KEYS.ANTHROPIC_KEY : STORAGE_KEYS.OPENAI_KEY;
-    const key = localStorage.getItem(storageKey);
-    if (key) {
-      return { key, provider };
-    }
-    for (const [name, storageKey2] of Object.entries(STORAGE_KEYS)) {
-      if (name === "PREVIEW_PROVIDER") continue;
-      const key2 = localStorage.getItem(storageKey2);
-      if (key2) {
-        return { key: key2, provider: name.replace("_KEY", "").toLowerCase() };
-      }
-    }
-    const boltApiKeys = getBoltApiKeys();
-    if (boltApiKeys) {
-      const providerMappings = [
-        { boltName: "OpenRouter", provider: "openrouter" },
-        { boltName: "Anthropic", provider: "anthropic" },
-        { boltName: "OpenAI", provider: "openai" },
-        // Also check with _API_KEY suffix (older format)
-        { boltName: "OpenRouter_API_KEY", provider: "openrouter" },
-        { boltName: "Anthropic_API_KEY", provider: "anthropic" },
-        { boltName: "OpenAI_API_KEY", provider: "openai" }
-      ];
-      for (const { boltName, provider: provider2 } of providerMappings) {
-        const apiKey = boltApiKeys[boltName];
-        if (apiKey && apiKey.length > 10 && !apiKey.includes("your_")) {
-          console.log(`[OpenCloudSDK] Using API key from bolt.diy (${provider2})`);
-          return { key: apiKey, provider: provider2 };
-        }
-      }
-    }
-    return null;
-  }
-  /**
-   * Call an AI model - automatically uses preview or production mode
-   */
-  async callAI(params) {
+  async trackUsage(params = {}) {
     if (!this.config.appId) {
-      throw new Error("OpenCloudSDK: Must call init() before using callAI()");
-    }
-    const { model, prompt, options = {} } = params;
-    if (!model || !prompt) {
-      throw new Error("OpenCloudSDK: model and prompt are required");
+      throw new Error("OpenCloudSDK: Must call init() before tracking usage");
     }
     if (this._isPreviewMode) {
-      return this.callAIPreview(params);
-    } else {
-      return this.callAIProduction(params);
-    }
-  }
-  /**
-   * Call AI in preview mode (direct to OpenRouter/provider)
-   */
-  async callAIPreview(params) {
-    const { model, prompt, options = {} } = params;
-    const apiKeyInfo = this.getPreviewApiKey();
-    if (!apiKeyInfo) {
-      throw new Error(
-        '[OpenCloudSDK Preview] No API key found. Please set your API key using opencloud.setPreviewApiKey("your-key") or configure it in the builder settings.'
-      );
+      console.log("[OpenCloudSDK Preview] Usage tracked (no charge in preview mode)");
+      return {
+        success: true,
+        charged: 0,
+        userBalance: 999.99,
+        transactionId: "preview-" + Date.now()
+      };
     }
-    const { key, provider } = apiKeyInfo;
     try {
-      let response;
-      let responseData;
-      if (provider === "openrouter" || provider === "openrouter_key") {
-        response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "Authorization": `Bearer ${key}`,
-            "HTTP-Referer": window.location.origin,
-            "X-Title": this.config.appId
-          },
-          body: JSON.stringify({
-            model,
-            messages: [{ role: "user", content: prompt }],
-            ...options
-          })
-        });
-        responseData = await response.json();
-        if (!response.ok) {
-          throw new Error(responseData.error?.message || `OpenRouter API error: ${response.status}`);
-        }
-        return {
-          success: true,
-          text: responseData.choices?.[0]?.message?.content || "",
-          usage: {
-            promptTokens: responseData.usage?.prompt_tokens || 0,
-            completionTokens: responseData.usage?.completion_tokens || 0,
-            totalTokens: responseData.usage?.total_tokens || 0
-          },
-          cost: 0,
-          // Preview mode - no cost tracking
-          model,
-          mode: "preview"
-        };
-      } else if (provider === "anthropic" || provider === "anthropic_key") {
-        response = await fetch("https://api.anthropic.com/v1/messages", {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "x-api-key": key,
-            "anthropic-version": "2023-06-01",
-            "anthropic-dangerous-direct-browser-access": "true"
-          },
-          body: JSON.stringify({
-            model: model.replace("anthropic/", ""),
-            max_tokens: options.max_tokens || 1024,
-            messages: [{ role: "user", content: prompt }]
-          })
-        });
-        responseData = await response.json();
-        if (!response.ok) {
-          throw new Error(responseData.error?.message || `Anthropic API error: ${response.status}`);
-        }
-        return {
-          success: true,
-          text: responseData.content?.[0]?.text || "",
-          usage: {
-            promptTokens: responseData.usage?.input_tokens || 0,
-            completionTokens: responseData.usage?.output_tokens || 0,
-            totalTokens: (responseData.usage?.input_tokens || 0) + (responseData.usage?.output_tokens || 0)
-          },
-          cost: 0,
-          model,
-          mode: "preview"
-        };
-      } else if (provider === "openai" || provider === "openai_key") {
-        response = await fetch("https://api.openai.com/v1/chat/completions", {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "Authorization": `Bearer ${key}`
-          },
-          body: JSON.stringify({
-            model: model.replace("openai/", ""),
-            messages: [{ role: "user", content: prompt }],
-            ...options
-          })
-        });
-        responseData = await response.json();
-        if (!response.ok) {
-          throw new Error(responseData.error?.message || `OpenAI API error: ${response.status}`);
+      const session = await this.getUserSession();
+      const response = await fetch(`${this.config.apiUrl}/api/sdk/track-usage`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${session.token}`
+        },
+        body: JSON.stringify({
+          appId: this.config.appId,
+          action: params.action,
+          metadata: params.metadata
+        })
+      });
+      if (!response.ok) {
+        const error = await response.json();
+        if (response.status === 402) {
+          throw new Error("INSUFFICIENT_BALANCE");
         }
-        return {
-          success: true,
-          text: responseData.choices?.[0]?.message?.content || "",
-          usage: {
-            promptTokens: responseData.usage?.prompt_tokens || 0,
-            completionTokens: responseData.usage?.completion_tokens || 0,
-            totalTokens: responseData.usage?.total_tokens || 0
-          },
-          cost: 0,
-          model,
-          mode: "preview"
-        };
+        throw new Error(error.error || `Failed to track usage: ${response.status}`);
       }
-      throw new Error(`Unsupported provider: ${provider}`);
+      return await response.json();
     } catch (error) {
-      console.error("[OpenCloudSDK Preview] AI call failed:", error);
+      console.error("[OpenCloudSDK] Track usage failed:", error);
       throw error;
     }
   }
   /**
-   * Call AI in production mode (through OpenCloud API)
+   * Check if the user can afford to use the app
+   * Returns true if user has enough balance
    */
-  async callAIProduction(params) {
-    const { model, prompt, options = {} } = params;
+  async canAfford() {
+    if (this._isPreviewMode) {
+      return true;
+    }
     try {
       const session = await this.getUserSession();
-      const response = await fetch(`${this.config.apiUrl}/api/ai/call`, {
+      const response = await fetch(`${this.config.apiUrl}/api/sdk/can-afford`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
           "Authorization": `Bearer ${session.token}`
         },
         body: JSON.stringify({
-          appId: this.config.appId,
-          model,
-          prompt,
-          options
+          appId: this.config.appId
         })
       });
       if (!response.ok) {
-        const error = await response.json();
-        throw new Error(error.error || `API call failed: ${response.status}`);
+        return false;
       }
       const data = await response.json();
-      return {
-        ...data,
-        mode: "production"
-      };
+      return data.canAfford;
     } catch (error) {
-      console.error("[OpenCloudSDK Production] AI call failed:", error);
-      throw error;
+      console.error("[OpenCloudSDK] canAfford check failed:", error);
+      return false;
     }
   }
   /**
-   * Get current user's balance (production only)
+   * Get current user's balance
    */
   async getBalance() {
     if (this._isPreviewMode) {
-      console.warn("[OpenCloudSDK] getBalance() not available in preview mode");
-      return 0;
+      return 999.99;
     }
     try {
       const session = await this.getUserSession();
-      const response = await fetch(`${this.config.apiUrl}/api/user/balance`, {
+      const response = await fetch(`${this.config.apiUrl}/api/sdk/balance`, {
         headers: {
           "Authorization": `Bearer ${session.token}`
         }
@@ -320,9 +155,54 @@ var OpenCloudSDK = class {
     }
   }
   /**
-   * Request user to purchase more tokens
+   * Get current user info
+   */
+  async getUserInfo() {
+    if (this._isPreviewMode) {
+      return {
+        id: "preview-user",
+        email: "preview@example.com",
+        balance: 999.99,
+        username: "preview_user"
+      };
+    }
+    try {
+      const session = await this.getUserSession();
+      const response = await fetch(`${this.config.apiUrl}/api/sdk/user`, {
+        headers: {
+          "Authorization": `Bearer ${session.token}`
+        }
+      });
+      if (!response.ok) {
+        throw new Error("Failed to get user info");
+      }
+      return await response.json();
+    } catch (error) {
+      console.error("[OpenCloudSDK] Get user info failed:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get the price per use for this app
+   */
+  async getAppPrice() {
+    try {
+      const response = await fetch(`${this.config.apiUrl}/api/sdk/app-price?appId=${this.config.appId}`);
+      if (!response.ok) {
+        throw new Error("Failed to get app price");
+      }
+      const data = await response.json();
+      return data.pricePerUse;
+    } catch (error) {
+      console.error("[OpenCloudSDK] Get app price failed:", error);
+      throw error;
+    }
+  }
+  /**
+   * Request user to add more credits
+   * Opens the top-up modal or redirects to payment page
    */
-  async requestTopUp() {
+  requestTopUp() {
     if (!isBrowser) return;
     if (this._isPreviewMode) {
       console.warn("[OpenCloudSDK] Top-up not available in preview mode");
@@ -334,45 +214,72 @@ var OpenCloudSDK = class {
         appId: this.config.appId
       }, "*");
     } else {
-      window.location.href = `${this.config.apiUrl}/topup`;
+      window.location.href = `${this.config.apiUrl}/settings/credits`;
     }
   }
   /**
-   * Start sending heartbeats
+   * Check if user is authenticated
    */
+  async isAuthenticated() {
+    if (this._isPreviewMode) {
+      return true;
+    }
+    try {
+      await this.getUserSession();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Request user to log in
+   */
+  requestLogin() {
+    if (!isBrowser) return;
+    if (this._isPreviewMode) {
+      console.warn("[OpenCloudSDK] Login not required in preview mode");
+      return;
+    }
+    if (window.parent !== window) {
+      window.parent.postMessage({
+        type: "OPENCLOUD_REQUEST_LOGIN",
+        appId: this.config.appId
+      }, "*");
+    } else {
+      window.location.href = `${this.config.apiUrl}/auth/login?redirect=${encodeURIComponent(window.location.href)}`;
+    }
+  }
   startHeartbeat() {
     if (!isBrowser) return;
     this.sendHeartbeat();
     this.heartbeatInterval = setInterval(() => this.sendHeartbeat(), 3e4);
   }
-  /**
-   * Send heartbeat to platform
-   */
   sendHeartbeat() {
     if (!this.config.appId || !isBrowser) return;
     const data = JSON.stringify({
       appId: this.config.appId,
       timestamp: Date.now(),
-      version: "1.1.0",
+      version: "2.0.0",
       url: window.location.href
     });
     if (navigator.sendBeacon) {
       navigator.sendBeacon(`${this.config.apiUrl}/api/sdk/heartbeat`, data);
     }
   }
-  /**
-   * Get user session token
-   */
   async getUserSession() {
     if (!isBrowser) {
       throw new Error("getUserSession can only be called in browser");
     }
+    if (this._cachedSession) {
+      return this._cachedSession;
+    }
     return new Promise((resolve, reject) => {
       if (window.parent !== window) {
         const messageHandler = (event) => {
           if (event.data.type === "USER_SESSION_RESPONSE") {
             window.removeEventListener("message", messageHandler);
             if (event.data.session) {
+              this._cachedSession = event.data.session;
               resolve(event.data.session);
             } else {
               reject(new Error("User not authenticated"));
@@ -391,6 +298,7 @@ var OpenCloudSDK = class {
       } else {
         const token = localStorage.getItem("opencloud_session_token");
         if (token) {
+          this._cachedSession = { token };
           resolve({ token });
         } else {
           reject(new Error("User not authenticated. Please log in."));
@@ -399,18 +307,51 @@ var OpenCloudSDK = class {
     });
   }
   /**
-   * Cleanup
+   * Clear cached session (call on logout)
+   */
+  clearSession() {
+    this._cachedSession = null;
+  }
+  /**
+   * Cleanup resources
    */
   destroy() {
     if (this.heartbeatInterval) {
       clearInterval(this.heartbeatInterval);
     }
+    this._cachedSession = null;
+  }
+  /**
+   * Execute a function and automatically charge the user
+   * This is a convenience method that combines canAfford + your code + trackUsage
+   *
+   * @param fn - The async function to execute (your AI call, etc.)
+   * @param options - Optional tracking options
+   * @returns The result of your function
+   *
+   * Example:
+   * ```typescript
+   * const result = await opencloud.withUsage(async () => {
+   *   const response = await fetch('https://api.openai.com/...', { ... });
+   *   return await response.json();
+   * }, { action: 'chat_message' });
+   * ```
+   */
+  async withUsage(fn, options = {}) {
+    const canUse = await this.canAfford();
+    if (!canUse) {
+      this.requestTopUp();
+      throw new Error("INSUFFICIENT_BALANCE");
+    }
+    const result = await fn();
+    await this.trackUsage(options);
+    return result;
   }
 };
 var opencloud = new OpenCloudSDK();
 if (isBrowser) {
   window.OpenCloudSDK = opencloud;
-  window.PlatformSDK = opencloud;
+  window.opencloud = opencloud;
 }
 export {
   OpenCloudSDK,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencloud-platform-sdk",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "description": "Official SDK for OpenCloud - AI App Marketplace",
   "main": "dist/index.js",
   "module": "dist/index.mjs",