@promptbook/remote-server 0.98.0 → 0.99.0-0

package/esm/typings/src/config.d.ts

@@ -138,6 +138,9 @@ export declare const SMALL_NUMBER = 0.001;
 /**
  * Timeout for the connections in milliseconds
  *
+ * Note: Increased from 7 seconds to 30 seconds to accommodate OAuth flows
+ * like Facebook login which may require user interaction and redirects
+ *
  * @private within the repository - too low-level in comparison with other `MAX_...`
  */
 export declare const CONNECTION_TIMEOUT_MS: number;
@@ -147,6 +150,13 @@ export declare const CONNECTION_TIMEOUT_MS: number;
  * @private within the repository - too low-level in comparison with other `MAX_...`
  */
 export declare const CONNECTION_RETRIES_LIMIT = 5;
+/**
+ * Timeout specifically for OAuth authentication flows in milliseconds
+ * OAuth flows typically require more time due to user interaction and redirects
+ *
+ * @private within the repository - too low-level in comparison with other `MAX_...`
+ */
+export declare const OAUTH_TIMEOUT_MS: number;
 /**
  * Short time interval to prevent race conditions in milliseconds
  *

package/esm/typings/src/remote-server/connection-improvements.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/typings/src/remote-server/utils/connectionProgress.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Connection progress utilities for better user experience during authentication
+ */
+/**
+ * Connection status types for better progress indication
+ *
+ * @private
+ */
+export type ConnectionStatus = 'connecting' | 'authenticating' | 'connected' | 'disconnected' | 'error' | 'timeout';
+/**
+ * Progress callback function type for connection status updates
+ *
+ * @private
+ */
+export type ConnectionProgressCallback = (status: ConnectionStatus, message?: string) => void;
+/**
+ * Enhanced connection options with progress reporting
+ *
+ * @private
+ */
+export interface ConnectionProgressOptions {
+    onProgress?: ConnectionProgressCallback;
+    enableProgressReporting?: boolean;
+}
+/**
+ * Default progress messages for different connection states
+ *
+ * @private
+ */
+export declare const DEFAULT_PROGRESS_MESSAGES: {
+    readonly connecting: "Connecting to Promptbook server...";
+    readonly authenticating: "Authenticating with social provider (Facebook, Google, etc.)...";
+    readonly connected: "Successfully connected to Promptbook server";
+    readonly disconnected: "Disconnected from Promptbook server";
+    readonly error: "Connection failed";
+    readonly timeout: "Connection timed out - this may happen during social login flows";
+};
+/**
+ * Creates a progress reporter for connection status
+ * This can be used by frontend applications to show connection progress
+ *
+ * @private
+ */
+export declare function createConnectionProgressReporter(callback?: ConnectionProgressCallback): ConnectionProgressCallback;
+/**
+ * Timeout constants with descriptions for different connection types
+ *
+ * @private
+ */
+export declare const CONNECTION_TIMEOUTS: {
+    /** Standard timeout for regular connections */
+    readonly STANDARD: number;
+    /** Extended timeout for OAuth flows that require user interaction */
+    readonly OAUTH: number;
+    /** Short timeout for quick health checks */
+    readonly HEALTH_CHECK: number;
+};
+/**
+ * Helper function to get appropriate timeout based on connection type
+ *
+ * @private
+ */
+export declare function getConnectionTimeout(type: 'standard' | 'oauth' | 'health_check'): number;
+/**
+ * Creates a timeout wrapper with progress reporting
+ *
+ * @private
+ */
+export declare function createTimeoutWithProgress(timeoutMs: number, onProgress?: ConnectionProgressCallback): Promise<never>;
+/**
+ * Note: [💞] Ignore a discrepancy between file name and entity name
+ */

package/esm/typings/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.98.0-10`).
+ * It follows semantic versioning (e.g., `0.98.0`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/remote-server",
-    "version": "0.98.0",
+    "version": "0.99.0-0",
     "description": "Promptbook: Run AI apps in plain human language across multiple models and platforms",
     "private": false,
     "sideEffects": false,
@@ -95,7 +95,7 @@
     "module": "./esm/index.es.js",
     "typings": "./esm/typings/src/_packages/remote-server.index.d.ts",
     "peerDependencies": {
-        "@promptbook/core": "0.98.0"
+        "@promptbook/core": "0.99.0-0"
     },
     "dependencies": {
         "colors": "1.4.0",

package/umd/index.umd.js

@@ -48,7 +48,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.98.0';
+    const PROMPTBOOK_ENGINE_VERSION = '0.99.0-0';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -8076,6 +8076,152 @@
                 response.status(400).send({ error: serializeError(error) });
             }
         });
+        // OAuth Authentication Endpoints
+        // These endpoints provide social authentication support (Facebook, Google, etc.)
+        app.get('/auth/:provider', async (request, response) => {
+            const { provider } = request.params;
+            if (!isApplicationModeAllowed) {
+                response.status(400).json({
+                    error: 'Application mode is not allowed',
+                    message: 'Social authentication requires application mode to be enabled'
+                });
+                return;
+            }
+            try {
+                // Get OAuth configuration from query params or environment
+                const { redirectUri, clientId, appId } = request.query;
+                if (!redirectUri || !clientId) {
+                    response.status(400).json({
+                        error: 'Missing OAuth parameters',
+                        message: 'redirectUri and clientId are required for OAuth flow'
+                    });
+                    return;
+                }
+                let authUrl;
+                const state = Buffer.from(JSON.stringify({
+                    appId: appId || 'default',
+                    timestamp: Date.now()
+                })).toString('base64');
+                switch (provider.toLowerCase()) {
+                    case 'facebook':
+                        authUrl = `https://www.facebook.com/v18.0/dialog/oauth?` +
+                            `client_id=${encodeURIComponent(clientId)}&` +
+                            `redirect_uri=${encodeURIComponent(redirectUri)}&` +
+                            `scope=email,public_profile&` +
+                            `response_type=code&` +
+                            `state=${encodeURIComponent(state)}`;
+                        break;
+                    case 'google':
+                        authUrl = `https://accounts.google.com/o/oauth2/v2/auth?` +
+                            `client_id=${encodeURIComponent(clientId)}&` +
+                            `redirect_uri=${encodeURIComponent(redirectUri)}&` +
+                            `scope=openid%20email%20profile&` +
+                            `response_type=code&` +
+                            `state=${encodeURIComponent(state)}`;
+                        break;
+                    default:
+                        response.status(400).json({
+                            error: 'Unsupported provider',
+                            message: `Social authentication provider '${provider}' is not supported. Supported providers: facebook, google`
+                        });
+                        return;
+                }
+                // Log the OAuth attempt for debugging
+                if (isVerbose) {
+                    console.info(colors__default["default"].cyan(`OAuth ${provider} flow started for app ${appId || 'default'}`));
+                }
+                response.json({
+                    authUrl,
+                    provider,
+                    state,
+                    message: `Redirect user to authUrl to complete ${provider} authentication`
+                });
+            }
+            catch (error) {
+                assertsError(error);
+                console.warn(`OAuth ${provider} initialization failed:`, error);
+                response.status(500).json({
+                    error: 'OAuth initialization failed',
+                    message: error.message
+                });
+            }
+        });
+        app.post('/auth/:provider/callback', async (request, response) => {
+            const { provider } = request.params;
+            if (!isApplicationModeAllowed || login === null) {
+                response.status(400).json({
+                    error: 'Application mode is not allowed',
+                    message: 'Social authentication requires application mode and login handler to be configured'
+                });
+                return;
+            }
+            try {
+                const { code, state, error: oauthError } = request.body;
+                if (oauthError) {
+                    response.status(400).json({
+                        isSuccess: false,
+                        error: 'OAuth authorization failed',
+                        message: `${provider} authentication was denied or failed: ${oauthError}`
+                    });
+                    return;
+                }
+                if (!code || !state) {
+                    response.status(400).json({
+                        isSuccess: false,
+                        error: 'Missing OAuth callback parameters',
+                        message: 'code and state parameters are required'
+                    });
+                    return;
+                }
+                // Decode state to get app information
+                let appInfo;
+                try {
+                    appInfo = JSON.parse(Buffer.from(state, 'base64').toString());
+                }
+                catch (_a) {
+                    response.status(400).json({
+                        isSuccess: false,
+                        error: 'Invalid state parameter',
+                        message: 'The OAuth state parameter is malformed'
+                    });
+                    return;
+                }
+                // Log the OAuth callback for debugging
+                if (isVerbose) {
+                    console.info(colors__default["default"].cyan(`OAuth ${provider} callback received for app ${appInfo.appId}`));
+                }
+                // Note: In a real implementation, you would:
+                // 1. Exchange the code for an access token with the OAuth provider
+                // 2. Use the access token to get user information
+                // 3. Create or find the user in your system
+                // 4. Call the login function with the user's information
+                // For now, we provide a framework that the implementer can extend
+                const mockUserInfo = {
+                    username: `${provider}_user_${code.substring(0, 8)}`,
+                    password: '',
+                    appId: appInfo.appId
+                };
+                const loginResult = await login({
+                    ...mockUserInfo,
+                    rawRequest: request,
+                    rawResponse: response,
+                });
+                response.status(200).json({
+                    ...loginResult,
+                    provider,
+                    message: loginResult.message || `${provider} authentication completed`,
+                });
+            }
+            catch (error) {
+                assertsError(error);
+                console.warn(`OAuth ${provider} callback failed:`, error);
+                response.status(500).json({
+                    isSuccess: false,
+                    error: 'OAuth callback processing failed',
+                    message: error.message
+                });
+            }
+        });
         app.get(`/books`, async (request, response) => {
             if (collection === null) {
                 response.status(500).send('No collection available');