@kapeta/local-cluster-service 0.67.4 → 0.68.0

package/src/storm/PageGenerator.ts

@@ -7,7 +7,7 @@ import uuid from 'node-uuid';
 import { stormClient, UIPagePrompt } from './stormClient';
 import { ReferenceClassification, StormEvent, StormEventPage, StormImage, UIShell } from './events';
 import { EventEmitter } from 'node:events';
-import { createFuture, Future, FuturePromise, PromiseQueue } from './PromiseQueue';
+import { PromiseQueue } from './PromiseQueue';
 import { hasPageOnDisk } from './page-utils';
 
 export interface ImagePrompt {
@@ -24,6 +24,7 @@ type InitialPrompt = Omit<UIPagePrompt, 'shell_page'> & { shellType?: 'public' |
 
 export class PageQueue extends EventEmitter {
     private readonly queue: PromiseQueue;
+    private readonly eventQueue: PromiseQueue;
     private readonly systemId: string;
     private readonly systemPrompt: string;
     private readonly references: Map<string, PageGenerator> = new Map();
@@ -37,19 +38,22 @@ export class PageQueue extends EventEmitter {
         this.systemId = systemId;
         this.systemPrompt = systemPrompt;
         this.queue = new PromiseQueue(concurrency);
+        this.eventQueue = new PromiseQueue(Number.MAX_VALUE);
     }
 
-    on(event: 'event', listener: (data: StormEvent) => void): this;
-    on(event: 'page', listener: (data: StormEventPage) => void): this;
-    on(event: 'image', listener: (data: StormImage, source: ImagePrompt, future: FuturePromise<void>) => void): this;
+    on(event: 'event', listener: (data: StormEvent) => void | Promise<void>): this;
+    on(event: 'page', listener: (data: StormEventPage) => void | Promise<void>): this;
+    on(event: 'image', listener: (data: StormImage, source: ImagePrompt) => void | Promise<void>): this;
 
-    on(event: string, listener: (...args: any[]) => void): this {
-        return super.on(event, listener);
+    on(event: string, listener: (...args: any[]) => void | Promise<void>): this {
+        return super.on(event, (...args) => {
+            void this.eventQueue.add(async () => listener(...args));
+        });
     }
 
     emit(type: 'event', event: StormEvent): boolean;
     emit(type: 'page', event: StormEventPage): boolean;
-    emit(type: 'image', event: StormImage, source: ImagePrompt, future: FuturePromise<void>): boolean;
+    emit(type: 'image', event: StormImage, source: ImagePrompt): boolean;
     emit(eventName: string | symbol, ...args: any[]): boolean {
         return super.emit(eventName, ...args);
     }
@@ -81,6 +85,7 @@ export class PageQueue extends EventEmitter {
             //console.log('Ignoring duplicate prompt', initialPrompt.path);
             return Promise.resolve();
         }
+        console.log('Generating page for', initialPrompt.method, initialPrompt.path);
 
         const prompt: UIPagePrompt = {
             ...initialPrompt,
@@ -104,7 +109,7 @@ export class PageQueue extends EventEmitter {
     }
 
     private wrapPagePrompt(pagePath: string, prompt: string): string {
-        let promptPrefix = this.getPrefix();
+        const promptPrefix = this.getPrefix();
         let promptPostfix = '';
 
         if (this.pages.size > 0) {
@@ -129,10 +134,10 @@ export class PageQueue extends EventEmitter {
 
     private async addPageGenerator(generator: PageGenerator) {
         generator.on('event', (event: StormEvent) => this.emit('event', event));
-        generator.on('page_refs', async ({ event, references, future }) => {
+        generator.on('page_refs', async ({ event, references }) => {
             try {
                 const initialPrompts: InitialPrompt[] = [];
-                let promises = references.map(async (reference) => {
+                const resourcePromises = references.map(async (reference) => {
                     if (
                         reference.url.startsWith('#') ||
                         reference.url.startsWith('javascript:') ||
@@ -174,8 +179,12 @@ export class PageQueue extends EventEmitter {
                     }
                 });
 
-                await Promise.allSettled(promises);
-                initialPrompts.forEach((prompt) => {
+                // Wait for resources to be generated
+                await Promise.allSettled(resourcePromises);
+                this.emit('page', event);
+
+                // Emit any new pages after the current page to increase responsiveness
+                const newPages = initialPrompts.map((prompt) => {
                     if (!this.hasPrompt(prompt.path)) {
                         this.emit('page', {
                             type: 'PAGE',
@@ -194,12 +203,12 @@ export class PageQueue extends EventEmitter {
                             },
                         });
                     }
-                    this.addPrompt(prompt);
+                    return this.addPrompt(prompt);
                 });
-
-                this.emit('page', event);
-            } finally {
-                future.resolve();
+                await Promise.allSettled(newPages);
+            } catch (e) {
+                console.error('Failed to process event', e);
+                throw e;
             }
         });
         return this.queue.add(() => generator.generate());
@@ -207,10 +216,12 @@ export class PageQueue extends EventEmitter {
 
     public cancel() {
         this.queue.cancel();
+        this.eventQueue.cancel();
     }
 
-    public wait() {
-        return this.queue.wait();
+    public async wait() {
+        await this.eventQueue.wait();
+        await this.queue.wait();
     }
 
     private async addImagePrompt(prompt: ImagePrompt) {
@@ -225,29 +236,18 @@ export class PageQueue extends EventEmitter {
         );
 
         //console.log('Adding image prompt', prompt);
-
-        const futures: FuturePromise<void>[] = [];
-
-        result.on('data', async (event: StormEvent) => {
+        result.on('data', (event: StormEvent) => {
             if (event.type === 'IMAGE') {
-                const future = createFuture();
-                futures.push(future);
-                this.emit('image', event, prompt, future);
-                setTimeout(() => {
-                    if (!future.isResolved()) {
-                        console.log('Image prompt timed out', prompt);
-                        future.reject(new Error('Image prompt timed out'));
-                    }
-                }, 30000);
+                this.emit('image', event, prompt);
             }
         });
 
         await result.waitForDone();
-        await Promise.allSettled(futures.map((f) => f.promise));
     }
 }
 
 export class PageGenerator extends EventEmitter {
+    private readonly eventQueue: PromiseQueue;
     private readonly conversationId: string;
     public readonly prompt: UIPagePrompt;
 
@@ -255,64 +255,54 @@ export class PageGenerator extends EventEmitter {
         super();
         this.conversationId = conversationId;
         this.prompt = prompt;
+        this.eventQueue = new PromiseQueue(Number.MAX_VALUE);
     }
 
     on(event: 'event', listener: (data: StormEvent) => void): this;
     on(
         event: 'page_refs',
-        listener: (data: {
-            event: StormEventPage;
-            references: ReferenceClassification[];
-            future: FuturePromise<void>;
-        }) => void
+        listener: (data: { event: StormEventPage; references: ReferenceClassification[] }) => Promise<void>
     ): this;
 
     on(event: string, listener: (...args: any[]) => void): this {
-        return super.on(event, listener);
+        return super.on(event, (...args) => {
+            void this.eventQueue.add(async () => listener(...args));
+        });
     }
 
     emit(type: 'event', event: StormEvent): boolean;
-    emit(
-        type: 'page_refs',
-        event: { event: StormEventPage; references: ReferenceClassification[]; future: FuturePromise<void> }
-    ): boolean;
+    emit(type: 'page_refs', event: { event: StormEventPage; references: ReferenceClassification[] }): boolean;
     emit(eventName: string | symbol, ...args: any[]): boolean {
         return super.emit(eventName, ...args);
     }
 
     public async generate() {
-        return new Promise<void>(async (resolve) => {
-            const promises: Promise<void>[] = [];
-            const screenStream = await stormClient.createUIPage(this.prompt, this.conversationId);
-
-            screenStream.on('data', (event: StormEvent) => {
-                if (event.type === 'PAGE') {
-                    event.payload.conversationId = this.conversationId;
-
-                    promises.push(
-                        (async () => {
-                            const references = await this.resolveReferences(event.payload.content);
-                            //console.log('Resolved references for page', references, event.payload);
-                            const future = createFuture();
-                            this.emit('page_refs', {
-                                event,
-                                references,
-                                future,
-                            });
-
-                            await future.promise;
-                        })()
-                    );
-                    return;
-                }
-
-                this.emit('event', event);
-            });
+        const promises: Promise<void>[] = [];
+        const screenStream = await stormClient.createUIPage(this.prompt, this.conversationId);
+
+        screenStream.on('data', (event: StormEvent) => {
+            if (event.type === 'PAGE') {
+                event.payload.conversationId = this.conversationId;
+
+                promises.push(
+                    (async () => {
+                        const references = await this.resolveReferences(event.payload.content);
+                        //console.log('Resolved references for page', references, event.payload);
+                        this.emit('page_refs', {
+                            event,
+                            references,
+                        });
+                    })()
+                );
+                return;
+            }
 
-            await screenStream.waitForDone();
-            await Promise.all(promises);
-            resolve();
+            this.emit('event', event);
         });
+
+        await screenStream.waitForDone();
+        await Promise.all(promises);
+        await this.eventQueue.wait();
     }
 
     private async resolveReferences(content: string) {

package/src/storm/page-utils.ts

@@ -19,7 +19,7 @@ function normalizePath(path: string) {
     return path
         .replace(/\?.*$/gi, '')
         .replace(/:[a-z][a-z_]*\b/gi, '*')
-        .replace(/\{[a-z]+}/gi, '*');
+        .replace(/\{[a-z-.]+}/gi, '*');
 }
 
 export async function writePageToDisk(systemId: string, event: StormEventPage) {
@@ -69,13 +69,8 @@ export async function writeImageToDisk(systemId: string, event: StormImage, prom
 }
 
 export function hasPageOnDisk(systemId: string, method: string, path: string) {
-    if (!systemId || !method || !path) {
-        return false;
-    }
-    const baseDir = getSystemBaseDir(systemId);
-    const filePath = getFilePath(method);
-    const fullPath = Path.join(baseDir, normalizePath(path), filePath);
-    return FS.existsSync(fullPath);
+    const fullPath = resolveReadPath(systemId, method, path);
+    return !!fullPath && FS.existsSync(fullPath);
 }
 
 export function getSystemBaseDir(systemId: string) {
@@ -114,7 +109,7 @@ export function resolveReadPath(systemId: string, path: string, method: string)
 
     let currentPath = '';
 
-    for (let part in parts) {
+    for (let part of parts) {
         const thisPath = Path.join(currentPath, part);
         const starPath = Path.join(currentPath, '*');
         const thisPathDir = Path.join(baseDir, thisPath);
@@ -130,7 +125,6 @@ export function resolveReadPath(systemId: string, path: string, method: string)
             continue;
         }
 
-        console.log('Path not found', thisPathDir, starPathDir);
         // Path not found
         return null;
     }
@@ -150,15 +144,101 @@ export function readPageFromDiskAsString(systemId: string, path: string, method:
 export function readPageFromDisk(systemId: string, path: string, method: string, res: Response) {
     const filePath = resolveReadPath(systemId, path, method);
     if (!filePath || !FS.existsSync(filePath)) {
-        res.status(404).send('Page not found');
+        if (method === 'HEAD') {
+            // For HEAD requests, only return the status and headers
+            res.status(202).set('Retry-After', '3').end();
+        } else {
+            // For GET requests, return the fallback HTML with status 202
+            res.status(202).set('Retry-After', '3').send(getFallbackHtml(path, method));
+        }
         return;
     }
 
     res.type(filePath.split('.').pop() as string);
 
     const content = FS.readFileSync(filePath);
-    res.write(content);
-    res.end();
+
+    if (method === 'HEAD') {
+        // For HEAD requests, just end the response after setting headers
+        res.status(200).end();
+    } else {
+        // For GET requests, return the full content
+        res.write(content);
+        res.end();
+    }
+}
+
+function getFallbackHtml(path: string, method: string): string {
+    return `
+        <!DOCTYPE html>
+        <html lang="en">
+
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>Page Not Ready</title>
+            <style>
+                @import url('https://fonts.googleapis.com/css2?family=Roboto:wght@400;600&display=swap');
+
+                body {
+                    margin: 0;
+                    padding: 0;
+                    display: flex;
+                    align-items: center;
+                    justify-content: center;
+                    height: 100vh;
+                    font-family: 'Roboto', sans-serif;
+                    background: #1E1F20;
+                    color: white;
+                    text-align: center;
+                }
+
+                h1 {
+                    font-size: 2rem;
+                    font-weight: 600;
+                    margin-bottom: 1rem;
+                }
+
+                p {
+                    font-size: 1rem;
+                    font-weight: 400;
+                }
+            </style>
+        </head>
+
+        <body>
+            <div>
+                <h1>Page Not Ready</h1>
+                <p>Henrik is still working on this page. Please wait...</p>
+            </div>
+            <script>
+                const checkInterval = 3000;
+                function checkPageReady() {
+                    fetch('${path}', { method: 'HEAD' })
+                        .then(response => {
+                            if (response.status === 200) {
+                                // The page is ready, reload to fetch it
+                                window.location.reload(); 
+                            } else if (response.status === 202) {
+                                const retryAfter = response.headers.get('Retry-After');
+                                const retryInterval = retryAfter ? parseInt(retryAfter) * 1000 : 3000;
+                                setTimeout(checkPageReady, retryInterval);
+                            } else {
+                                // Handle other unexpected statuses
+                                setTimeout(checkPageReady, 3000);
+                            }
+                        })
+                        .catch(error => {
+                            console.error('Error checking page status:', error);
+                            setTimeout(checkPageReady, checkInterval);
+                        });
+                }
+                setTimeout(checkPageReady, checkInterval); 
+            </script>
+        </body>
+
+        </html>        
+    `;
 }
 
 export interface Conversation {

package/src/storm/routes.ts

@@ -102,24 +102,17 @@ router.post('/ui/screen', async (req: KapetaBodyRequest, res: Response) => {
 
         const promises: Promise<void>[] = [];
 
-        queue.on('page', (data) => {
-            if (systemId) {
-                promises.push(sendPageEvent(systemId, data, res));
-            }
-        });
+        queue.on('page', (data) => (systemId ? sendPageEvent(systemId, data, res) : undefined));
 
-        queue.on('image', async (screenData, prompt, future) => {
+        queue.on('image', async (screenData, prompt) => {
             if (!systemId) {
                 return;
             }
             try {
-                const promise = handleImageEvent(systemId, screenData, prompt);
-                promises.push(promise);
-                await promise;
-                future.resolve();
+                await handleImageEvent(systemId, screenData, prompt);
             } catch (e) {
                 console.error('Failed to handle image event', e);
-                future.reject(e);
+                throw e;
             }
         });
 
@@ -229,19 +222,16 @@ router.post('/:handle/ui/iterative', async (req: KapetaBodyRequest, res: Respons
             pageQueue.cancel();
         });
 
-        pageQueue.on('page', (screenData: StormEventPage) => {
-            pageEventPromises.push(sendPageEvent(landingPagesStream.getConversationId(), screenData, res));
-        });
+        pageQueue.on('page', (screenData: StormEventPage) =>
+            sendPageEvent(landingPagesStream.getConversationId(), screenData, res)
+        );
 
-        pageQueue.on('image', async (screenData, prompt, future) => {
+        pageQueue.on('image', async (screenData, prompt) => {
             try {
-                const promise = handleImageEvent(landingPagesStream.getConversationId(), screenData, prompt);
-                pageEventPromises.push(promise);
-                await promise;
-                future.resolve();
+                await handleImageEvent(landingPagesStream.getConversationId(), screenData, prompt);
             } catch (e) {
                 console.error('Failed to handle image event', e);
-                future.reject(e);
+                throw e;
             }
         });
 
@@ -420,25 +410,18 @@ router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
             created: Date.now(),
         });
 
-        const pagePromises: Promise<void>[] = [];
         onRequestAborted(req, res, () => {
             queue.cancel();
         });
 
-        const pageEventPromises: Promise<void>[] = [];
-        queue.on('page', (screenData: StormEventPage) => {
-            pageEventPromises.push(sendPageEvent(outerConversationId, screenData, res));
-        });
+        queue.on('page', (screenData: StormEventPage) => sendPageEvent(outerConversationId, screenData, res));
 
-        queue.on('image', async (screenData, prompt, future) => {
+        queue.on('image', async (screenData, prompt) => {
             try {
-                const promise = handleImageEvent(outerConversationId, screenData, prompt);
-                pageEventPromises.push(promise);
-                await promise;
-                future.resolve();
+                await handleImageEvent(outerConversationId, screenData, prompt);
             } catch (e) {
                 console.error('Failed to handle image event', e);
-                future.reject(e);
+                throw e;
             }
         });
 
@@ -447,8 +430,8 @@ router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
         });
 
         for (const screen of Object.values(uniqueUserJourneyScreens)) {
-            pagePromises.push(
-                queue.addPrompt({
+            queue
+                .addPrompt({
                     prompt: screen.requirements,
                     method: screen.method,
                     path: screen.path,
@@ -459,7 +442,9 @@ router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
                     storage_prefix: outerConversationId + '_',
                     theme,
                 })
-            );
+                .catch((e) => {
+                    console.error('Failed to generate page for screen %s', screen.name, e);
+                });
         }
 
         if (userJourneysStream.isAborted()) {
@@ -467,8 +452,6 @@ router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
         }
 
         await queue.wait();
-        await Promise.allSettled(pagePromises);
-        await Promise.allSettled(pageEventPromises);
 
         sendDone(res);
     } catch (err) {