@base44-preview/sdk 0.8.48-pr.282.c69fdcd → 0.8.48-pr.283.2de4c8a

package/README.md

@@ -7,6 +7,24 @@ You can use it in two ways:
 - **Inside Base44 apps**: When Base44 generates your app, the SDK is already set up and ready to use.
 - **External apps**: Use the SDK to build your own frontend or backend that uses Base44 as a backend service.
 
+## Platform SDK (server)
+
+The same package includes a separate server entry point for provisioning users and
+managing their apps:
+
+```ts
+import { Base44PlatformClient } from "@base44/sdk/platform/server";
+
+const platform = new Base44PlatformClient({ apiKey, workspaceId });
+await platform.users.provision({ externalId: "customer_42" });
+const apps = await platform.asUser("customer_42").apps.list();
+```
+
+Use this entry point only on your server. `tokenStore` is optional and defaults to
+in-memory caching. See the [platform guide](platform-docs/README.md),
+[complete API reference](platform-docs/api.md), and [token lifecycle](platform-docs/tokens.md).
+The existing `@base44/sdk` root import continues to provide the runtime SDK.
+
 ## Installation
 
 **Inside Base44 apps**: The SDK is already available. No installation needed.

package/dist/client.js

@@ -5,7 +5,6 @@ import { createAuthModule } from "./modules/auth.js";
 import { createSsoModule } from "./modules/sso.js";
 import { createConnectorsModule, createUserConnectorsModule, } from "./modules/connectors.js";
 import { getAccessToken } from "./utils/auth-utils.js";
-import { exchangeEmbedToken, isEmbeddedTab, markEmbeddedTab, takeEmbedTokenFromUrl, } from "./utils/embed-session.js";
 import { createFetchWithAuth } from "./utils/fetch-with-auth.js";
 import { createFunctionsModule } from "./modules/functions.js";
 import { createAgentsModule } from "./modules/agents.js";
@@ -55,26 +54,15 @@ import { createActorsModule, resolveActorsHost, } from "./modules/actors.js";
  */
 export function createClient(config) {
     var _a, _b, _c, _d;
-    const { serverUrl = "https://base44.app", appId, analytics, serviceToken, requiresAuth = false, appBaseUrl, options, functionsVersion, headers: optionalHeaders, } = config;
+    const { serverUrl = "https://base44.app", appId, analytics, token, serviceToken, requiresAuth = false, appBaseUrl, options, functionsVersion, headers: optionalHeaders, } = config;
     // Normalize appBaseUrl to always be a string (empty if not provided or invalid)
     const normalizedAppBaseUrl = typeof appBaseUrl === "string" ? appBaseUrl : "";
-    const embedOtt = takeEmbedTokenFromUrl();
-    if (embedOtt) {
-        markEmbeddedTab();
-    }
-    const embedded = Boolean(embedOtt) || isEmbeddedTab();
-    // What an app passes as `token` is whatever getAccessToken() returned as the
-    // page loaded. In an embedded frame that is the one-time token itself, or a
-    // token an earlier visitor left in storage; neither is this session.
-    const token = embedded ? undefined : config.token;
     const socketConfig = {
         serverUrl,
         mountPath: "/ws-user-apps/socket.io/",
         transports: ["websocket"],
         appId,
-        // null (not undefined): an embedded frame's only identity is the one the
-        // platform minted, so the socket must not fall back to a stored token.
-        token: embedded ? null : token,
+        token,
     };
     let socket = null;
     const getSocket = () => {
@@ -137,66 +125,26 @@ export function createClient(config) {
         appBaseUrl: normalizedAppBaseUrl,
         serverUrl,
         token,
-        embedded,
     });
     // Apply the access token before any module that may issue authenticated
     // requests during construction (notably analytics, which fires an init
     // event whose flush calls auth.me()). Without this, the first User/me
     // request is built before setToken runs and goes out unauthenticated.
-    // An embedded load skips this: its session comes from the exchange below,
-    // and a token an earlier visitor left in storage must not become it.
-    if (typeof window !== "undefined" && !embedded) {
+    if (typeof window !== "undefined") {
         const accessToken = token || getAccessToken();
         if (accessToken) {
             userAuthModule.setToken(accessToken);
         }
     }
-    // The one answer every module reads. Follows setToken and logout; outside an
-    // embedded frame it still falls back to storage, so a login in another tab is
-    // picked up on the next connection, as before.
-    const getToken = () => { var _a; return (_a = userAuthModule.getToken()) !== null && _a !== void 0 ? _a : (embedded ? null : getAccessToken()); };
-    const applyToken = (newToken, saveToStorage) => {
-        userAuthModule.setToken(newToken, saveToStorage);
-        socketConfig.token = newToken;
-        if (socket) {
-            socket.updateConfig({ token: newToken });
-        }
-    };
-    // Resolves once the embedded session is in hand (or known not to be coming);
-    // immediately for every other client. The exchanged token is applied without
-    // persisting it: the session must not outlive the frame it was minted for.
-    const authReady = embedOtt
-        ? exchangeEmbedToken({ serverUrl, appId, ott: embedOtt }).then((sessionToken) => {
-            if (sessionToken) {
-                applyToken(sessionToken, false);
-            }
-        })
-        : Promise.resolve();
-    if (embedOtt) {
-        // Requests issued while the exchange is in flight wait for it and carry the
-        // session it produces. Registered after createAxiosClient's interceptors,
-        // so it runs first and the anonymous-visitor header sees the Authorization.
-        for (const client of [axiosClient, functionsAxiosClient]) {
-            client.interceptors.request.use(async (requestConfig) => {
-                await authReady;
-                const sessionToken = getToken();
-                if (sessionToken && !requestConfig.headers.get("Authorization")) {
-                    requestConfig.headers.set("Authorization", `Bearer ${sessionToken}`);
-                }
-                return requestConfig;
-            });
-        }
-    }
     const actorsModule = createActorsModule({
         appId,
         // serverUrl is often relative/empty (same-origin app); the proxy-fallback
         // URL needs an absolute host, so fall back to the page origin.
         host: resolveActorsHost(serverUrl, typeof window !== "undefined" ? (_a = window.location) === null || _a === void 0 ? void 0 : _a.origin : undefined),
         functionsVersion,
-        getAuthToken: getToken,
+        getAuthToken: () => token || getAccessToken(),
         mintConnectionToken: async (actorName, room, connectionId) => {
-            await authReady;
-            const authToken = getToken();
+            const authToken = token || getAccessToken();
             return await actorsAxiosClient.post(`/apps/${appId}/actors/${encodeURIComponent(actorName)}/connection-token`, { room, connection_id: connectionId }, {
                 headers: {
                     ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
@@ -223,9 +171,10 @@ export function createClient(config) {
         functions: createFunctionsModule(functionsAxiosClient, appId, {
             getAuthHeaders: () => {
                 const headers = {};
-                const sessionToken = getToken();
-                if (sessionToken) {
-                    headers["Authorization"] = `Bearer ${sessionToken}`;
+                // Get current token from storage or initial config
+                const currentToken = token || getAccessToken();
+                if (currentToken) {
+                    headers["Authorization"] = `Bearer ${currentToken}`;
                 }
                 return headers;
             },
@@ -236,9 +185,9 @@ export function createClient(config) {
             getSocket,
             appId,
             serverUrl,
-            getToken,
+            token,
         }),
-        aiGateway: createAiGatewayModule({ serverUrl, getToken, appId }),
+        aiGateway: createAiGatewayModule({ serverUrl, token, appId }),
         appLogs: createAppLogsModule(axiosClient, appId),
         app: createAppModule(axiosClient, appId),
         users: createUsersModule(axiosClient, appId),
@@ -283,13 +232,9 @@ export function createClient(config) {
             getSocket,
             appId,
             serverUrl,
-            getToken: () => token,
-        }),
-        aiGateway: createAiGatewayModule({
-            serverUrl,
-            getToken: () => serviceToken,
-            appId,
+            token,
         }),
+        aiGateway: createAiGatewayModule({ serverUrl, token: serviceToken, appId }),
         appLogs: createAppLogsModule(serviceRoleAxiosClient, appId),
         cleanup: () => {
             if (socket) {
@@ -329,7 +274,6 @@ export function createClient(config) {
          * Sets a new authentication token for all subsequent requests.
          *
          * @param newToken - The new authentication token
-         * @param saveToStorage - Whether to also keep the token in local storage. Defaults to `true`.
          *
          * @example
          * ```typescript
@@ -341,8 +285,14 @@ export function createClient(config) {
          * base44.setToken(access_token);
          * ```
          */
-        setToken(newToken, saveToStorage = true) {
-            applyToken(newToken, saveToStorage);
+        setToken(newToken) {
+            userModules.auth.setToken(newToken);
+            if (socket) {
+                socket.updateConfig({
+                    token: newToken,
+                });
+            }
+            socketConfig.token = newToken;
         },
         /**
          * Gets the current client configuration.

package/dist/client.types.d.ts

@@ -200,9 +200,8 @@ export interface Base44Client {
      * Updates the token for both HTTP requests and WebSocket connections.
      *
      * @param newToken - The new authentication token.
-     * @param saveToStorage - Whether to also keep the token in local storage so it survives a page load. Defaults to `true`.
      */
-    setToken(newToken: string, saveToStorage?: boolean): void;
+    setToken(newToken: string): void;
     /**
      * Gets the current client configuration.
      * @internal

package/dist/modules/agents.d.ts

@@ -1,2 +1,2 @@
 import { AgentsModule, AgentsModuleConfig } from "./agents.types.js";
-export declare function createAgentsModule({ axios, getSocket, appId, serverUrl, getToken, }: AgentsModuleConfig): AgentsModule;
+export declare function createAgentsModule({ axios, getSocket, appId, serverUrl, token, }: AgentsModuleConfig): AgentsModule;

package/dist/modules/agents.js

@@ -1,4 +1,5 @@
-export function createAgentsModule({ axios, getSocket, appId, serverUrl, getToken, }) {
+import { getAccessToken } from "../utils/auth-utils.js";
+export function createAgentsModule({ axios, getSocket, appId, serverUrl, token, }) {
     const baseURL = `/apps/${appId}/agents`;
     // Track active conversations
     const currentConversations = {};
@@ -55,7 +56,7 @@ export function createAgentsModule({ axios, getSocket, appId, serverUrl, getToke
     };
     const getWhatsAppConnectURL = (agentName) => {
         const baseUrl = `${serverUrl}/api/apps/${appId}/agents/${encodeURIComponent(agentName)}/whatsapp`;
-        const accessToken = getToken();
+        const accessToken = token !== null && token !== void 0 ? token : getAccessToken();
         if (accessToken) {
             return `${baseUrl}?token=${accessToken}`;
         }
@@ -66,7 +67,7 @@ export function createAgentsModule({ axios, getSocket, appId, serverUrl, getToke
     };
     const getTelegramConnectURL = (agentName) => {
         const baseUrl = `${serverUrl}/api/apps/${appId}/agents/${encodeURIComponent(agentName)}/telegram`;
-        const accessToken = getToken();
+        const accessToken = token !== null && token !== void 0 ? token : getAccessToken();
         if (accessToken) {
             return `${baseUrl}?token=${accessToken}`;
         }

package/dist/modules/agents.types.d.ts

@@ -160,8 +160,8 @@ export interface AgentsModuleConfig {
     appId: string;
     /** Server URL */
     serverUrl?: string;
-    /** Returns the current authentication token, if any */
-    getToken: () => string | null | undefined;
+    /** Authentication token */
+    token?: string;
 }
 /**
  * Agents module for managing AI agent conversations.

package/dist/modules/ai-gateway.d.ts

@@ -1,2 +1,2 @@
 import { AiGatewayModule, AiGatewayModuleConfig } from "./ai-gateway.types.js";
-export declare function createAiGatewayModule({ serverUrl, getToken, appId, }: AiGatewayModuleConfig): AiGatewayModule;
+export declare function createAiGatewayModule({ serverUrl, token, appId, }: AiGatewayModuleConfig): AiGatewayModule;

package/dist/modules/ai-gateway.js

@@ -1,9 +1,10 @@
-export function createAiGatewayModule({ serverUrl, getToken, appId, }) {
+import { getAccessToken } from "../utils/auth-utils.js";
+export function createAiGatewayModule({ serverUrl, token, appId, }) {
     const connection = () => {
         var _a;
         return ({
             baseURL: `${serverUrl}/api/apps/${appId}/ai/openai/v1`,
-            token: (_a = getToken()) !== null && _a !== void 0 ? _a : "",
+            token: (_a = token !== null && token !== void 0 ? token : getAccessToken()) !== null && _a !== void 0 ? _a : "",
         });
     };
     return {

package/dist/modules/ai-gateway.types.d.ts

@@ -17,8 +17,8 @@ export interface AiGatewayConnection {
 export interface AiGatewayModuleConfig {
     /** Server URL */
     serverUrl?: string;
-    /** Returns the current authentication token, if any */
-    getToken: () => string | null | undefined;
+    /** Authentication token */
+    token?: string;
     /** Application ID */
     appId: string;
 }

package/dist/modules/auth.js

@@ -1,5 +1,4 @@
 import { resetAnalyticsSessionContext } from "./analytics.js";
-import { showEmbedSessionEnded } from "../utils/embed-session.js";
 function isInsideIframe() {
     if (typeof window === "undefined")
         return false;
@@ -82,16 +81,10 @@ export function createAuthModule(axios, functionsAxiosClient, appId, options) {
     // Tracked here rather than read off `axios.defaults` so the answer stays tied
     // to the identity transitions below (`setToken`, `logout`) instead of to the
     // header a caller may have set on the instance directly.
-    let accessToken = options.token || null;
+    let hasAccessToken = Boolean(options.token);
     return {
         hasToken() {
-            return accessToken !== null;
-        },
-        getToken() {
-            return accessToken;
-        },
-        isEmbedded() {
-            return Boolean(options.embedded);
+            return hasAccessToken;
         },
         // Get current user information
         async me() {
@@ -116,12 +109,6 @@ export function createAuthModule(axios, functionsAxiosClient, appId, options) {
             if (typeof window === "undefined") {
                 throw new Error("Login method can only be used in a browser environment");
             }
-            // An embedded session can only be renewed by the host platform; the
-            // login round trip cannot complete inside its frame.
-            if (options.embedded) {
-                showEmbedSessionEnded();
-                return;
-            }
             // If nextUrl is not provided, use the current URL
             const redirectUrl = nextUrl
                 ? new URL(nextUrl, window.location.origin).toString()
@@ -164,7 +151,7 @@ export function createAuthModule(axios, functionsAxiosClient, appId, options) {
             // flight would otherwise resolve into callers that run after the logout.
             clearPendingMe();
             resetAnalyticsSessionContext();
-            accessToken = null;
+            hasAccessToken = false;
             // Only do the rest if in a browser environment
             if (typeof window !== "undefined") {
                 // Remove token from localStorage
@@ -193,7 +180,7 @@ export function createAuthModule(axios, functionsAxiosClient, appId, options) {
             // resolved for the previous one must not be handed to later callers.
             clearPendingMe();
             resetAnalyticsSessionContext();
-            accessToken = token;
+            hasAccessToken = true;
             // handle token change for axios clients
             axios.defaults.headers.common["Authorization"] = `Bearer ${token}`;
             functionsAxiosClient.defaults.headers.common["Authorization"] = `Bearer ${token}`;

package/dist/modules/auth.types.d.ts

@@ -98,11 +98,6 @@ export interface AuthModuleOptions {
      * which is how the server-side SDK reports a token it never sets explicitly.
      */
     token?: string;
-    /**
-     * Whether this client runs embedded in a host platform's frame, where a
-     * session is minted by the platform and cannot be renewed by a login redirect.
-     */
-    embedded?: boolean;
 }
 /**
  * Authentication module for managing user authentication and authorization. The module automatically stores tokens in local storage when available and manages authorization headers for API requests.
@@ -184,22 +179,6 @@ export interface AuthModule {
      * ```
      */
     redirectToLogin(nextUrl: string): void;
-    /**
-     * Whether the app is running embedded in a host platform.
-     *
-     * A platform embeds an app in an iframe and signs its user in by minting a one-time token onto the frame's URL; the SDK trades it for a session as the client is created. That session is held in memory only and can be renewed only by the platform, so when it ends there is no login page to send the user to — {@linkcode AuthModule.redirectToLogin | redirectToLogin()} shows a "session ended" notice instead. Use this to render your own notice or to hide sign-in and sign-out controls that cannot work inside the frame.
-     *
-     * @returns `true` when the app was embedded by a host platform, `false` otherwise.
-     *
-     * @example
-     * ```typescript
-     * // Show your own message instead of a login screen
-     * if (!user && base44.auth.isEmbedded()) {
-     *   return <SessionEnded />;
-     * }
-     * ```
-     */
-    isEmbedded(): boolean;
     /**
      * Redirects the user to a third-party authentication provider's login page.
      *
@@ -560,9 +539,4 @@ export interface InternalAuthModule extends AuthModule {
      * could not succeed without a session, not to decide that one is valid.
      */
     hasToken(): boolean;
-    /**
-     * The access token currently set on the client, or `null` when there is none.
-     * Follows {@linkcode AuthModule.setToken | setToken} and {@linkcode AuthModule.logout | logout}.
-     */
-    getToken(): string | null;
 }

package/dist/platform/server/client.d.ts

@@ -0,0 +1,29 @@
+import type { PlatformClientConfig, TokenRequestOptions } from "./types.js";
+import type { UsersModule } from "./modules/users.types.js";
+import type { AppsModule } from "./modules/apps.types.js";
+/** Immutable server-side view of one provisioned user; never a browser session. */
+export interface PlatformUserClient {
+    /** Canonical caller-owned external ID, not the Base44 user ID. */
+    readonly externalId: string;
+    /** App operations authenticated as this user. */
+    readonly apps: AppsModule;
+    /** Lazily mint/reuse a server credential. Never send the result to the browser. */
+    getAccessToken(options?: TokenRequestOptions): Promise<string>;
+    /** Revoke refresh credentials and clear storage even if remote revocation fails. Does not deprovision. */
+    revokeToken(): Promise<void>;
+}
+/** Server-only client for provisioning users and managing their apps.
+ * @example
+ * const platform = new Base44PlatformClient({ apiKey, workspaceId });
+ * await platform.users.provision({ externalId: "customer_42" });
+ * const apps = await platform.asUser("customer_42").apps.list();
+ */
+export declare class Base44PlatformClient {
+    #private;
+    /** Explicit identity provisioning and offboarding, using the configured workspace API key. */
+    readonly users: UsersModule;
+    /** Construct without network access. One key must support provisioning and minting. */
+    constructor(config: PlatformClientConfig);
+    /** Bind a previously provisioned external user ID. Lazy, synchronous and safe to call concurrently. */
+    asUser(value: string): PlatformUserClient;
+}

package/dist/platform/server/client.js

@@ -0,0 +1,57 @@
+import { Base44PlatformError } from "./errors.js";
+import { InMemoryTokenStore } from "./token-store.js";
+import { Tokens } from "./tokens.js";
+import { Transport, checkAbort, waitFor } from "./transport.js";
+import { createUsers } from "./modules/users.js";
+import { createApps } from "./modules/apps.js";
+import { externalId, identifier, invalid, positive } from "./validation.js";
+/** Server-only client for provisioning users and managing their apps.
+ * @example
+ * const platform = new Base44PlatformClient({ apiKey, workspaceId });
+ * await platform.users.provision({ externalId: "customer_42" });
+ * const apps = await platform.asUser("customer_42").apps.list();
+ */
+export class Base44PlatformClient {
+    /** Explicit identity provisioning and offboarding, using the configured workspace API key. */
+    users;
+    #transport;
+    #tokens;
+    #workspaceId;
+    #buildTimeoutMs;
+    /** Construct without network access. One key must support provisioning and minting. */
+    constructor(config) {
+        if (typeof window !== "undefined")
+            throw new Base44PlatformError("server_only", "The platform client must run on your server.");
+        if (typeof config.apiKey !== "string" || !config.apiKey.trim())
+            invalid("apiKey is required.");
+        identifier(config.workspaceId);
+        let url;
+        try {
+            url = new URL(config.serverUrl ?? "https://base44.app");
+        }
+        catch {
+            invalid("serverUrl must be an absolute HTTP(S) URL.");
+        }
+        if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+            invalid("serverUrl must be an HTTP(S) URL without credentials, query or fragment.");
+        const serverUrl = url.toString().replace(/\/+$/, "");
+        this.#workspaceId = config.workspaceId;
+        this.#buildTimeoutMs = positive(config.buildTimeoutMs ?? 120_000);
+        this.#transport = new Transport(serverUrl, config.fetch ?? globalThis.fetch, positive(config.timeoutMs ?? 30_000));
+        this.#tokens = new Tokens(this.#transport, config.tokenStore ?? new InMemoryTokenStore(), config.apiKey, { serverUrl, workspaceId: config.workspaceId });
+        this.users = Object.freeze(createUsers(this.#transport, this.#tokens, config.apiKey));
+    }
+    /** Bind a previously provisioned external user ID. Lazy, synchronous and safe to call concurrently. */
+    asUser(value) {
+        const id = externalId(value);
+        return Object.freeze({
+            externalId: id,
+            apps: Object.freeze(createApps(this.#transport, this.#tokens, id, this.#workspaceId, this.#buildTimeoutMs)),
+            getAccessToken: async (options = {}) => {
+                checkAbort(options.signal);
+                return waitFor(this.#tokens.get(id, options.forceRefresh), options.signal);
+            },
+            revokeToken: () => this.#tokens.revoke(id),
+        });
+    }
+}

package/dist/platform/server/errors.d.ts

@@ -0,0 +1,28 @@
+/** Stable SDK failure categories; server response prose is never copied into errors. */
+export type PlatformErrorCode = "invalid_argument" | "server_only" | "http_error" | "invalid_response" | "network_error" | "timeout" | "aborted" | "token_store_error";
+/** Safe error representation, suitable for returning to your own application. */
+export interface PlatformErrorJSON {
+    /** Always Base44PlatformError. */
+    name: "Base44PlatformError";
+    /** SDK-defined message containing no request or response bodies. */
+    message: string;
+    /** HTTP status, or 0 for a local, network, cancellation or storage failure. */
+    status: number;
+    /** Stable SDK category; inspect status for HTTP failures. */
+    code: PlatformErrorCode;
+}
+/** All SDK failures use this error; no raw response, credential or fetch error is retained. */
+export declare class Base44PlatformError extends Error {
+    /** SDK failure category. */
+    readonly code: PlatformErrorCode;
+    /** HTTP status, or 0 if no HTTP failure response was received. */
+    readonly status: number;
+    /** Create a safe error from an SDK category, message and optional HTTP status. */
+    constructor(
+    /** SDK failure category. */
+    code: PlatformErrorCode, message: string, 
+    /** HTTP status, or 0 if no HTTP failure response was received. */
+    status?: number);
+    /** Return safe fields only; excludes stack traces and transport internals. */
+    toJSON(): PlatformErrorJSON;
+}

package/dist/platform/server/errors.js

@@ -0,0 +1,20 @@
+/** All SDK failures use this error; no raw response, credential or fetch error is retained. */
+export class Base44PlatformError extends Error {
+    code;
+    status;
+    /** Create a safe error from an SDK category, message and optional HTTP status. */
+    constructor(
+    /** SDK failure category. */
+    code, message, 
+    /** HTTP status, or 0 if no HTTP failure response was received. */
+    status = 0) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = "Base44PlatformError";
+    }
+    /** Return safe fields only; excludes stack traces and transport internals. */
+    toJSON() {
+        return { name: "Base44PlatformError", message: this.message, status: this.status, code: this.code };
+    }
+}

package/dist/platform/server/index.d.ts

@@ -0,0 +1,9 @@
+/** Server-side Base44 platform SDK. Runtime app entities remain in @base44/sdk. */
+export { Base44PlatformClient } from "./client.js";
+export type { PlatformUserClient } from "./client.js";
+export { Base44PlatformError } from "./errors.js";
+export type { PlatformErrorCode, PlatformErrorJSON } from "./errors.js";
+export { InMemoryTokenStore } from "./token-store.js";
+export type { PlatformClientConfig, RequestOptions, TokenRequestOptions, TokenKey, TokenRecord, TokenStore } from "./types.js";
+export type { UsersModule, ProvisionUserInput, ProvisionedUser, DeprovisionResult } from "./modules/users.types.js";
+export type { AppsModule, PlatformApp, AppState, ListAppsInput, CreateAppInput, PreviewResult, DeployResult } from "./modules/apps.types.js";

package/dist/platform/server/index.js

@@ -0,0 +1,4 @@
+/** Server-side Base44 platform SDK. Runtime app entities remain in @base44/sdk. */
+export { Base44PlatformClient } from "./client.js";
+export { Base44PlatformError } from "./errors.js";
+export { InMemoryTokenStore } from "./token-store.js";

package/dist/platform/server/modules/apps.d.ts

@@ -0,0 +1,4 @@
+import { Transport } from "../transport.js";
+import { Tokens } from "../tokens.js";
+import type { AppsModule } from "./apps.types.js";
+export declare function createApps(transport: Transport, tokens: Tokens, id: string, workspaceId: string, buildTimeoutMs: number): AppsModule;

package/dist/platform/server/modules/apps.js

@@ -0,0 +1,66 @@
+import { checkAbort, waitFor } from "../transport.js";
+import { object, identifier, requiredString, nullableString, badResponse, invalid } from "../validation.js";
+function projectApp(value) {
+    const data = object(value);
+    const state = data.status && typeof data.status === "object" ? object(data.status).state : undefined;
+    return {
+        id: requiredString(data.id), name: nullableString(data.name), slug: nullableString(data.slug),
+        state: state === "ready" || state === "processing" || state === "error" ? state : "unknown",
+        updatedAt: nullableString(data.updated_date), previewScreenshotUrl: nullableString(data.preview_screenshot_url),
+        logoUrl: nullableString(data.logo_url), lastDeployedAt: nullableString(data.last_deployed_at),
+        currentRevision: nullableString(data.last_git_commit_hash), deployedRevision: nullableString(data.last_deployed_git_commit_hash),
+        hasCustomInstructions: typeof data.custom_instructions === "string" && data.custom_instructions.length > 0,
+    };
+}
+export function createApps(transport, tokens, id, workspaceId, buildTimeoutMs) {
+    async function request(path, method, body, options = {}) {
+        checkAbort(options.signal);
+        const token = await waitFor(tokens.get(id), options.signal);
+        return transport.request(path, method, {
+            Authorization: `Bearer ${token}`, "X-Active-Workspace-Id": workspaceId, "Content-Type": "application/json",
+        }, body, options);
+    }
+    return {
+        async list(input = {}, options) {
+            const limit = input.limit ?? 20, skip = input.skip ?? 0;
+            if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(skip) || skip < 0)
+                invalid("limit must be positive and skip nonnegative integers.");
+            const query = new URLSearchParams({ q: JSON.stringify({ app_type: { $nin: ["user_agent"] } }), sort: "-updated_date", limit: String(limit), skip: String(skip), filter_mode: "all_apps_workspace" });
+            if (input.folderId !== undefined) {
+                identifier(input.folderId);
+                query.set("folder_id", input.folderId);
+            }
+            const data = await request(`/api/apps?${query}`, "GET", undefined, options);
+            return Array.isArray(data) ? data.map(projectApp) : badResponse();
+        },
+        async create(input, options) {
+            if (typeof input.prompt !== "string" || !input.prompt.trim())
+                invalid("An initial prompt is required.");
+            return projectApp(await request("/api/apps", "POST", {
+                name: input.name, user_description: input.prompt, organization_id: workspaceId,
+                public_settings: input.publicSettings, prevent_iframe_embedding: input.preventIframeEmbedding,
+                custom_instructions: input.customInstructions,
+                secrets: input.secrets === undefined ? undefined : Object.fromEntries(Object.entries(input.secrets).map(([key, value]) => [key, { type: "value", value }])),
+                initial_message: { content: input.prompt },
+            }, { timeoutMs: buildTimeoutMs, ...options }));
+        },
+        async get(appId, options) { return projectApp(await request(`/api/apps/${identifier(appId)}`, "GET", undefined, options)); },
+        async rename(appId, name, options) {
+            if (typeof name !== "string" || !name.trim())
+                invalid("A nonempty app name is required.");
+            return projectApp(await request(`/api/apps/${identifier(appId)}`, "PUT", { name: name.trim() }, options));
+        },
+        async addToFolder(folderId, appIds, options) {
+            appIds.forEach(identifier);
+            await request(`/api/app-folders/${identifier(folderId)}/items`, "POST", { app_ids: appIds }, options);
+        },
+        async getPreviewUrl(appId, options) {
+            const data = object(await request(`/api/apps/${identifier(appId)}/sandbox/preview-url`, "GET", undefined, options));
+            return { url: requiredString(data.preview_url), token: nullableString(data.preview_token) };
+        },
+        async deploy(appId, options) {
+            const data = object(await request(`/api/apps/${identifier(appId)}/deploy`, "POST", {}, { timeoutMs: buildTimeoutMs, ...options }));
+            return { appId: requiredString(data.app_id), checkpointId: nullableString(data.checkpoint_id), revision: requiredString(data.git_commit_hash), deployedAt: requiredString(data.deployed_at) };
+        },
+    };
+}