@promptbook/wizard 0.100.0-1 → 0.100.0-11

package/esm/index.es.js

@@ -38,7 +38,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
@@ -192,12 +192,9 @@ 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 = 30 * 1000;
+const CONNECTION_TIMEOUT_MS = 7 * 1000;
 // <- TODO: [⏳] Standardize timeouts, Make DEFAULT_TIMEOUT_MS as global constant
 /**
  * How many times to retry the connections
@@ -1389,39 +1386,13 @@ 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', () => {
-            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}`));
-            }
+            resolve(socket);
         });
-        // 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.`));
-            }
+        // TODO: [💩] Better timeout handling
+        setTimeout(() => {
+            reject(new Error(`Timeout while connecting to ${remoteServerUrl}`));
         }, CONNECTION_TIMEOUT_MS);
-        // Clean up timeout if connection succeeds
-        socket.on('connect', () => {
-            clearTimeout(timeoutId);
-        });
     });
 }
 
@@ -1467,33 +1438,8 @@ class RemoteLlmExecutionTools {
      * Check the configuration of all execution tools
      */
     async checkConfiguration() {
-        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
-        }
+        const socket = await createRemoteClient(this.options);
+        socket.disconnect();
         // TODO: [main] !!3 Check version of the remote server and compatibility
         // TODO: [🎍] Send checkConfiguration
     }
@@ -6017,7 +5963,23 @@ async function getScraperIntermediateSource(source, options) {
         .join('/') +
         '.' +
         extension;
-    await mkdir(dirname(cacheFilename), { recursive: true });
+    // Note: Try to create cache directory, but don't fail if filesystem has issues
+    try {
+        await mkdir(dirname(cacheFilename), { recursive: true });
+    }
+    catch (error) {
+        // Note: If we can't create cache directory, continue without it
+        //       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;
+        }
+    }
     let isDestroyed = true;
     const fileHandler = {
         filename: cacheFilename,
@@ -7781,12 +7743,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, {
@@ -10864,7 +10872,23 @@ class MarkitdownScraper {
                 // <- TODO: [🍀] Make MarkitdownError
             }
             // console.log('!!', { result, cacheFilehandler });
-            await this.tools.fs.writeFile(cacheFilehandler.filename, result.text_content);
+            // Note: Try to cache the converted content, but don't fail if the filesystem is read-only
+            try {
+                await this.tools.fs.writeFile(cacheFilehandler.filename, result.text_content);
+            }
+            catch (error) {
+                // Note: If we can't write to cache, we'll continue without caching
+                //       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'))) ;
+                else {
+                    // Re-throw other unexpected errors
+                    throw error;
+                }
+            }
         }
         return cacheFilehandler;
     }
@@ -11152,7 +11176,23 @@ class WebsiteScraper {
             extension: 'html',
             isVerbose,
         });
-        await this.tools.fs.writeFile(cacheFilehandler.filename, html, 'utf-8');
+        // Note: Try to cache the scraped content, but don't fail if the filesystem is read-only
+        try {
+            await this.tools.fs.writeFile(cacheFilehandler.filename, html, 'utf-8');
+        }
+        catch (error) {
+            // Note: If we can't write to cache, we'll continue without caching
+            //       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'))) ;
+            else {
+                // Re-throw other unexpected errors
+                throw error;
+            }
+        }
         const markdown = this.showdownConverter.makeMarkdown(html, jsdom.window.document);
         return { ...cacheFilehandler, markdown };
     }
@@ -11893,8 +11933,27 @@ class FileCacheStorage {
             throw new UnexpectedError(`The "${key}" you want to store in JSON file is not serializable as JSON`);
         }
         const fileContent = stringifyPipelineJson(value);
-        await mkdir(dirname(filename), { recursive: true }); // <- [0]
-        await writeFile(filename, fileContent, 'utf-8');
+        // Note: Try to create cache directory and write file, but don't fail if filesystem is read-only or has permission issues
+        try {
+            await mkdir(dirname(filename), { recursive: true }); // <- [0]
+            await writeFile(filename, fileContent, 'utf-8');
+        }
+        catch (error) {
+            // Note: If we can't write to cache, silently ignore the error
+            //       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'))) {
+                // Silently ignore filesystem errors - caching is optional
+                return;
+            }
+            else {
+                // Re-throw other unexpected errors
+                throw error;
+            }
+        }
     }
     /**
      * Removes the key/value pair with the given key from the storage, if a key/value pair with the given key exists.
@@ -16764,7 +16823,23 @@ async function $getCompiledBook(tools, pipelineSource, options) {
                     ...options,
                 });
                 const compiledFilePath = filePath.replace('.book.md', '.book').replace('.book', '.bookc');
-                await saveArchive(compiledFilePath, [pipelineJson], fs);
+                // Note: Try to save the compiled book to disk for caching, but don't fail if the filesystem is read-only
+                try {
+                    await saveArchive(compiledFilePath, [pipelineJson], fs);
+                }
+                catch (error) {
+                    // Note: Ignore filesystem errors (like EROFS on read-only systems like Vercel)
+                    //       The compiled book can still be used even if it can't be cached
+                    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;
+                    }
+                }
                 return pipelineJson;
             }
         }
@@ -16886,14 +16961,14 @@ class Wizard {
      *
      * Note: This works similar to the `ptbk run` command
      */
-    async execute(book, inputParameters) {
+    async execute(book, inputParameters, options = {}) {
         if (!$isRunningInNode()) {
             throw new EnvironmentMismatchError('Wizard works only in Node.js environment');
         }
         // ▶ Get the tools
-        const tools = await this.getExecutionTools();
+        const tools = await this.getExecutionTools(options);
         // ▶ Get the Pipeline
-        const pipeline = await this.getCompiledBook(book);
+        const pipeline = await this.getCompiledBook(book, options);
         // ▶ Create executor - the function that will execute the Pipeline
         const pipelineExecutor = createPipelineExecutor({ pipeline, tools });
         // 🚀▶ Execute the Pipeline
@@ -16916,15 +16991,16 @@ class Wizard {
     /**
      * Provides the tools automatically for the Node.js environment
      *
-     * @param pipelineSource
+     * @param options
      */
-    async getExecutionTools() {
+    async getExecutionTools(options = {}) {
+        var _a;
         if (this.executionTools !== null) {
             return this.executionTools;
         }
         // TODO: DRY [◽]
         const prepareAndScrapeOptions = {
-            isVerbose: false,
+            isVerbose: (_a = options.isVerbose) !== null && _a !== void 0 ? _a : false,
             isCacheReloaded: false, // <- TODO: Allow to pass
         }; /* <- TODO: ` satisfies PrepareAndScrapeOptions` */
         const fs = $provideFilesystemForNode();
@@ -16954,9 +17030,10 @@ class Wizard {
      * 3) As a string
      *
      * @param pipelineSource
+     * @param options
      */
-    async getCompiledBook(pipelineSource) {
-        const tools = await this.getExecutionTools();
+    async getCompiledBook(pipelineSource, options = {}) {
+        const tools = await this.getExecutionTools(options);
         return /* not await */ $getCompiledBook(tools, pipelineSource);
     }
 }