@promptbook/cli 0.98.0 → 0.100.0-0

package/README.md

@@ -25,6 +25,10 @@ Write AI applications using plain human language across multiple models and plat
 
 
 
+<blockquote style="color: #ff8811">
+    <b>⚠ Warning:</b> This is a pre-release version of the library. It is not yet ready for production use. Please look at <a href="https://www.npmjs.com/package/@promptbook/core?activeTab=versions">latest stable release</a>.
+</blockquote>
+
 ## 📦 Package `@promptbook/cli`
 
 - Promptbooks are [divided into several](#-packages) packages, all are published from [single monorepo](https://github.com/webgptorg/promptbook).

package/esm/index.es.js

@@ -47,7 +47,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.98.0';
+const PROMPTBOOK_ENGINE_VERSION = '0.100.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
@@ -221,9 +221,12 @@ 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_...`
  */
-const CONNECTION_TIMEOUT_MS = 7 * 1000;
+const CONNECTION_TIMEOUT_MS = 30 * 1000;
 // <- TODO: [⏳] Standardize timeouts, Make DEFAULT_TIMEOUT_MS as global constant
 /**
  * How many times to retry the connections
@@ -2560,13 +2563,39 @@ async function createRemoteClient(options) {
             transports: ['polling', 'websocket' /*, <- TODO: [🌬] Allow to pass `transports`, add 'webtransport' */],
         });
         // console.log('Connecting to', this.options.remoteServerUrl.href, { socket });
+        let isResolved = false;
         socket.on('connect', () => {
-            resolve(socket);
+            if (!isResolved) {
+                isResolved = true;
+                resolve(socket);
+            }
+        });
+        socket.on('connect_error', (error) => {
+            if (!isResolved) {
+                isResolved = true;
+                reject(new Error(`Failed to connect to ${remoteServerUrl}: ${error.message || error}`));
+            }
+        });
+        socket.on('disconnect', (reason) => {
+            if (!isResolved) {
+                isResolved = true;
+                reject(new Error(`Connection to ${remoteServerUrl} was disconnected: ${reason}`));
+            }
         });
-        // TODO: [💩] Better timeout handling
-        setTimeout(() => {
-            reject(new Error(`Timeout while connecting to ${remoteServerUrl}`));
+        // Better timeout handling with more descriptive error message
+        const timeoutId = setTimeout(() => {
+            if (!isResolved) {
+                isResolved = true;
+                socket.disconnect();
+                reject(new Error(`Connection timeout after ${CONNECTION_TIMEOUT_MS / 1000} seconds while connecting to ${remoteServerUrl}. ` +
+                    `This may indicate network issues or the server may be experiencing high load. ` +
+                    `For authentication flows like social login, ensure sufficient time is allowed for user interaction.`));
+            }
         }, CONNECTION_TIMEOUT_MS);
+        // Clean up timeout if connection succeeds
+        socket.on('connect', () => {
+            clearTimeout(timeoutId);
+        });
     });
 }
 
@@ -2595,8 +2624,33 @@ class RemoteLlmExecutionTools {
      * Check the configuration of all execution tools
      */
     async checkConfiguration() {
-        const socket = await createRemoteClient(this.options);
-        socket.disconnect();
+        try {
+            const socket = await createRemoteClient(this.options);
+            socket.disconnect();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                // Provide user-friendly error messages for common connection issues
+                if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+                    throw new Error(`Connection to Promptbook server timed out. This may happen during authentication flows like Facebook login. ` +
+                        `Please ensure: 1) Server is running at ${this.options.remoteServerUrl}, ` +
+                        `2) Network connection is stable, 3) Authentication process is completed within the timeout period. ` +
+                        `Original error: ${error.message}`);
+                }
+                if (error.message.includes('connect') || error.message.includes('ECONNREFUSED')) {
+                    throw new Error(`Cannot connect to Promptbook server at ${this.options.remoteServerUrl}. ` +
+                        `Please check if the server is running and accessible. ` +
+                        `Original error: ${error.message}`);
+                }
+                if (error.message.includes('authentication') || error.message.includes('auth')) {
+                    throw new Error(`Authentication failed when connecting to Promptbook server. ` +
+                        `This may happen if social login (like Facebook) was not completed properly. ` +
+                        `Please retry the authentication process. ` +
+                        `Original error: ${error.message}`);
+                }
+            }
+            throw error; // Re-throw if not a recognized error pattern
+        }
         // TODO: [main] !!3 Check version of the remote server and compatibility
         // TODO: [🎍] Send checkConfiguration
     }
@@ -14629,6 +14683,152 @@ function startRemoteServer(options) {
             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.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.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');