@promptbook/remote-server 0.100.0-1 → 0.100.0-11

package/esm/index.es.js

@@ -33,7 +33,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.100.0-1';
+const PROMPTBOOK_ENGINE_VERSION = '0.100.0-11';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -3822,12 +3822,58 @@ async function makeKnowledgeSourceHandler(knowledgeSource, tools, options) {
         //    <- TODO: [🥬] Encapsulate sha256 to some private utility function
         const rootDirname = join(process.cwd(), DEFAULT_DOWNLOAD_CACHE_DIRNAME);
         const filepath = join(...nameToSubfolderPath(hash /* <- TODO: [🎎] Maybe add some SHA256 prefix */), `${basename.substring(0, MAX_FILENAME_LENGTH)}.${mimeTypeToExtension(mimeType)}`);
-        await tools.fs.mkdir(dirname(join(rootDirname, filepath)), { recursive: true });
+        // Note: Try to create cache directory, but don't fail if filesystem has issues
+        try {
+            await tools.fs.mkdir(dirname(join(rootDirname, filepath)), { recursive: true });
+        }
+        catch (error) {
+            // Note: If we can't create cache directory, we'll handle it when trying to write the file
+            //       This handles read-only filesystems, permission issues, and missing parent directories
+            if (error instanceof Error && (error.message.includes('EROFS') ||
+                error.message.includes('read-only') ||
+                error.message.includes('EACCES') ||
+                error.message.includes('EPERM') ||
+                error.message.includes('ENOENT'))) ;
+            else {
+                // Re-throw other unexpected errors
+                throw error;
+            }
+        }
         const fileContent = Buffer.from(await response.arrayBuffer());
         if (fileContent.length > DEFAULT_MAX_FILE_SIZE /* <- TODO: Allow to pass different value to remote server */) {
             throw new LimitReachedError(`File is too large (${Math.round(fileContent.length / 1024 / 1024)}MB). Maximum allowed size is ${Math.round(DEFAULT_MAX_FILE_SIZE / 1024 / 1024)}MB.`);
         }
-        await tools.fs.writeFile(join(rootDirname, filepath), fileContent);
+        // Note: Try to cache the downloaded file, but don't fail if the filesystem is read-only
+        try {
+            await tools.fs.writeFile(join(rootDirname, filepath), fileContent);
+        }
+        catch (error) {
+            // Note: If we can't write to cache, we'll process the file directly from memory
+            //       This handles read-only filesystems like Vercel
+            if (error instanceof Error && (error.message.includes('EROFS') ||
+                error.message.includes('read-only') ||
+                error.message.includes('EACCES') ||
+                error.message.includes('EPERM') ||
+                error.message.includes('ENOENT'))) {
+                // Return a handler that works directly with the downloaded content
+                return {
+                    source: name,
+                    filename: null,
+                    url,
+                    mimeType,
+                    async asJson() {
+                        return JSON.parse(fileContent.toString('utf-8'));
+                    },
+                    async asText() {
+                        return fileContent.toString('utf-8');
+                    },
+                };
+            }
+            else {
+                // Re-throw other unexpected errors
+                throw error;
+            }
+        }
         // TODO: [💵] Check the file security
         // TODO: [🧹][🧠] Delete the file after the scraping is done
         return makeKnowledgeSourceHandler({ name, knowledgeSourceContent: filepath }, tools, {
@@ -8061,152 +8107,6 @@ 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');