bluera-knowledge 0.9.32 → 0.9.36

package/src/crawl/bridge.ts

@@ -1,6 +1,6 @@
 import { spawn, type ChildProcess } from 'node:child_process';
-import { createInterface } from 'node:readline';
 import { randomUUID } from 'node:crypto';
+import { createInterface } from 'node:readline';
 import { ZodError } from 'zod';
 import {
   type CrawlResult,
@@ -70,7 +70,8 @@ export class PythonBridge {
     }
 
     if (this.process.stdout === null) {
-      this.process = null;  // Clean up partial state
+      this.process.kill(); // Kill process to prevent zombie
+      this.process = null; // Clean up reference
       return Promise.reject(new Error('Python bridge process stdout is null'));
     }
     const rl = createInterface({ input: this.process.stdout });
@@ -111,11 +112,16 @@ export class PythonBridge {
             } catch (error: unknown) {
               // Log validation failure with original response for debugging
               if (error instanceof ZodError) {
-                logger.error({
-                  issues: error.issues,
-                  response: JSON.stringify(response.result),
-                }, 'Python bridge response validation failed');
-                pending.reject(new Error(`Invalid response format from Python bridge: ${error.message}`));
+                logger.error(
+                  {
+                    issues: error.issues,
+                    response: JSON.stringify(response.result),
+                  },
+                  'Python bridge response validation failed'
+                );
+                pending.reject(
+                  new Error(`Invalid response format from Python bridge: ${error.message}`)
+                );
               } else {
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 logger.error({ error: errorMessage }, 'Response validation error');
@@ -126,10 +132,13 @@ export class PythonBridge {
           // If neither result nor error, leave pending (will timeout)
         }
       } catch (err) {
-        logger.error({
-          error: err instanceof Error ? err.message : String(err),
-          line,
-        }, 'Failed to parse JSON response from Python bridge');
+        logger.error(
+          {
+            error: err instanceof Error ? err.message : String(err),
+            line,
+          },
+          'Failed to parse JSON response from Python bridge'
+        );
       }
     });
 
@@ -157,13 +166,18 @@ export class PythonBridge {
         }
       }, timeoutMs);
 
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      this.pending.set(id, { resolve: resolve as (v: PendingResult) => void, reject, timeout, method: 'crawl' });
-      if (this.process === null || this.process.stdin === null) {
+      this.pending.set(id, {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Promise resolve type narrowing
+        resolve: resolve as (v: PendingResult) => void,
+        reject,
+        timeout,
+        method: 'crawl',
+      });
+      if (!this.process?.stdin) {
         reject(new Error('Python bridge process not available'));
         return;
       }
-      this.process.stdin.write(JSON.stringify(request) + '\n');
+      this.process.stdin.write(`${JSON.stringify(request)}\n`);
     });
   }
 
@@ -187,17 +201,26 @@ export class PythonBridge {
         }
       }, timeoutMs);
 
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      this.pending.set(id, { resolve: resolve as (v: PendingResult) => void, reject, timeout, method: 'fetch_headless' });
-      if (this.process === null || this.process.stdin === null) {
+      this.pending.set(id, {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Promise resolve type narrowing
+        resolve: resolve as (v: PendingResult) => void,
+        reject,
+        timeout,
+        method: 'fetch_headless',
+      });
+      if (!this.process?.stdin) {
         reject(new Error('Python bridge process not available'));
         return;
       }
-      this.process.stdin.write(JSON.stringify(request) + '\n');
+      this.process.stdin.write(`${JSON.stringify(request)}\n`);
     });
   }
 
-  async parsePython(code: string, filePath: string, timeoutMs: number = 10000): Promise<ParsePythonResult> {
+  async parsePython(
+    code: string,
+    filePath: string,
+    timeoutMs: number = 10000
+  ): Promise<ParsePythonResult> {
     if (!this.process) await this.start();
 
     const id = randomUUID();
@@ -213,28 +236,62 @@ export class PythonBridge {
         const pending = this.pending.get(id);
         if (pending) {
           this.pending.delete(id);
-          reject(new Error(`Python parsing timeout after ${String(timeoutMs)}ms for file: ${filePath}`));
+          reject(
+            new Error(`Python parsing timeout after ${String(timeoutMs)}ms for file: ${filePath}`)
+          );
         }
       }, timeoutMs);
 
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      this.pending.set(id, { resolve: resolve as (v: PendingResult) => void, reject, timeout, method: 'parse_python' });
-      if (this.process === null || this.process.stdin === null) {
+      this.pending.set(id, {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Promise resolve type narrowing
+        resolve: resolve as (v: PendingResult) => void,
+        reject,
+        timeout,
+        method: 'parse_python',
+      });
+      if (!this.process?.stdin) {
         reject(new Error('Python bridge process not available'));
         return;
       }
-      this.process.stdin.write(JSON.stringify(request) + '\n');
+      this.process.stdin.write(`${JSON.stringify(request)}\n`);
     });
   }
 
   stop(): Promise<void> {
-    if (this.process) {
+    if (!this.process) {
+      return Promise.resolve();
+    }
+
+    return new Promise((resolve) => {
       this.stoppingIntentionally = true;
       this.rejectAllPending(new Error('Python bridge stopped'));
-      this.process.kill();
-      this.process = null;
-    }
-    return Promise.resolve();
+
+      // Wait for process to actually exit before resolving
+      const proc = this.process;
+      if (proc === null) {
+        resolve();
+        return;
+      }
+
+      // Set up exit handler to resolve when process terminates
+      const onExit = (): void => {
+        resolve();
+      };
+      proc.once('exit', onExit);
+
+      // Send SIGTERM to gracefully stop
+      proc.kill();
+
+      // Safety timeout in case process doesn't exit within 1 second
+      setTimeout(() => {
+        proc.removeListener('exit', onExit);
+        if (this.process === proc) {
+          proc.kill('SIGKILL'); // Force kill
+          this.process = null;
+        }
+        resolve();
+      }, 1000);
+    });
   }
 
   private rejectAllPending(error: Error): void {

package/src/crawl/claude-client.test.ts

@@ -85,10 +85,15 @@ describe('ClaudeClient', () => {
 
       // Simulate successful response
       setTimeout(() => {
-        mockProcess.stdout.emit('data', Buffer.from(JSON.stringify({
-          urls: ['https://example.com/page1', 'https://example.com/page2'],
-          reasoning: 'Found documentation pages',
-        })));
+        mockProcess.stdout.emit(
+          'data',
+          Buffer.from(
+            JSON.stringify({
+              urls: ['https://example.com/page1', 'https://example.com/page2'],
+              reasoning: 'Found documentation pages',
+            })
+          )
+        );
         mockProcess.emit('close', 0);
       }, 10);
 
@@ -101,10 +106,15 @@ describe('ClaudeClient', () => {
       const promise = client.determineCrawlUrls('<html>test</html>', 'Find all docs');
 
       setTimeout(() => {
-        mockProcess.stdout.emit('data', Buffer.from(JSON.stringify({
-          urls: ['https://example.com/page1'],
-          reasoning: 'Test',
-        })));
+        mockProcess.stdout.emit(
+          'data',
+          Buffer.from(
+            JSON.stringify({
+              urls: ['https://example.com/page1'],
+              reasoning: 'Test',
+            })
+          )
+        );
         mockProcess.emit('close', 0);
       }, 10);
 
@@ -121,7 +131,7 @@ describe('ClaudeClient', () => {
         ]),
         expect.objectContaining({
           stdio: ['pipe', 'pipe', 'pipe'],
-        }),
+        })
       );
     });
 
@@ -129,16 +139,23 @@ describe('ClaudeClient', () => {
       const promise = client.determineCrawlUrls('<html><body>Test</body></html>', 'Find tutorials');
 
       setTimeout(() => {
-        mockProcess.stdout.emit('data', Buffer.from(JSON.stringify({
-          urls: ['https://example.com/tutorial'],
-          reasoning: 'Found tutorial',
-        })));
+        mockProcess.stdout.emit(
+          'data',
+          Buffer.from(
+            JSON.stringify({
+              urls: ['https://example.com/tutorial'],
+              reasoning: 'Found tutorial',
+            })
+          )
+        );
         mockProcess.emit('close', 0);
       }, 10);
 
       await promise;
 
-      expect(mockProcess.stdin.write).toHaveBeenCalledWith(expect.stringContaining('Find tutorials'));
+      expect(mockProcess.stdin.write).toHaveBeenCalledWith(
+        expect.stringContaining('Find tutorials')
+      );
       expect(mockProcess.stdin.end).toHaveBeenCalled();
     });
 
@@ -146,9 +163,14 @@ describe('ClaudeClient', () => {
       const promise = client.determineCrawlUrls('<html>test</html>', 'Find all');
 
       setTimeout(() => {
-        mockProcess.stdout.emit('data', Buffer.from(JSON.stringify({
-          reasoning: 'No URLs found',
-        })));
+        mockProcess.stdout.emit(
+          'data',
+          Buffer.from(
+            JSON.stringify({
+              reasoning: 'No URLs found',
+            })
+          )
+        );
         mockProcess.emit('close', 0);
       }, 10);
 
@@ -159,10 +181,15 @@ describe('ClaudeClient', () => {
       const promise = client.determineCrawlUrls('<html>test</html>', 'Find all');
 
       setTimeout(() => {
-        mockProcess.stdout.emit('data', Buffer.from(JSON.stringify({
-          urls: [],
-          reasoning: 'No matching pages',
-        })));
+        mockProcess.stdout.emit(
+          'data',
+          Buffer.from(
+            JSON.stringify({
+              urls: [],
+              reasoning: 'No matching pages',
+            })
+          )
+        );
         mockProcess.emit('close', 0);
       }, 10);
 
@@ -173,9 +200,14 @@ describe('ClaudeClient', () => {
       const promise = client.determineCrawlUrls('<html>test</html>', 'Find all');
 
       setTimeout(() => {
-        mockProcess.stdout.emit('data', Buffer.from(JSON.stringify({
-          urls: ['https://example.com/page1'],
-        })));
+        mockProcess.stdout.emit(
+          'data',
+          Buffer.from(
+            JSON.stringify({
+              urls: ['https://example.com/page1'],
+            })
+          )
+        );
         mockProcess.emit('close', 0);
       }, 10);
 
@@ -186,10 +218,15 @@ describe('ClaudeClient', () => {
       const promise = client.determineCrawlUrls('<html>test</html>', 'Find all');
 
       setTimeout(() => {
-        mockProcess.stdout.emit('data', Buffer.from(JSON.stringify({
-          urls: ['https://example.com/page1', 123, null],
-          reasoning: 'Mixed types',
-        })));
+        mockProcess.stdout.emit(
+          'data',
+          Buffer.from(
+            JSON.stringify({
+              urls: ['https://example.com/page1', 123, null],
+              reasoning: 'Mixed types',
+            })
+          )
+        );
         mockProcess.emit('close', 0);
       }, 10);
 
@@ -223,10 +260,15 @@ describe('ClaudeClient', () => {
       const promise = client.determineCrawlUrls(longHtml, 'Find all');
 
       setTimeout(() => {
-        mockProcess.stdout.emit('data', Buffer.from(JSON.stringify({
-          urls: ['https://example.com/page1'],
-          reasoning: 'Test',
-        })));
+        mockProcess.stdout.emit(
+          'data',
+          Buffer.from(
+            JSON.stringify({
+              urls: ['https://example.com/page1'],
+              reasoning: 'Test',
+            })
+          )
+        );
         mockProcess.emit('close', 0);
       }, 10);
 
@@ -242,10 +284,15 @@ describe('ClaudeClient', () => {
       const promise = client.determineCrawlUrls(shortHtml, 'Find all');
 
       setTimeout(() => {
-        mockProcess.stdout.emit('data', Buffer.from(JSON.stringify({
-          urls: ['https://example.com/page1'],
-          reasoning: 'Test',
-        })));
+        mockProcess.stdout.emit(
+          'data',
+          Buffer.from(
+            JSON.stringify({
+              urls: ['https://example.com/page1'],
+              reasoning: 'Test',
+            })
+          )
+        );
         mockProcess.emit('close', 0);
       }, 10);
 
@@ -259,7 +306,10 @@ describe('ClaudeClient', () => {
 
   describe('extractContent', () => {
     it('should successfully extract content', async () => {
-      const promise = client.extractContent('# Documentation\n\nPricing: $10/month', 'Extract pricing info');
+      const promise = client.extractContent(
+        '# Documentation\n\nPricing: $10/month',
+        'Extract pricing info'
+      );
 
       setTimeout(() => {
         mockProcess.stdout.emit('data', Buffer.from('The pricing is $10/month\n'));
@@ -285,7 +335,7 @@ describe('ClaudeClient', () => {
         ['-p'],
         expect.objectContaining({
           stdio: ['pipe', 'pipe', 'pipe'],
-        }),
+        })
       );
     });
 
@@ -515,12 +565,15 @@ describe('ClaudeClient', () => {
       const promise = client.determineCrawlUrls('<html>test</html>', 'Find all');
 
       setTimeout(() => {
-        mockProcess.stdout.emit('data', Buffer.from(`
+        mockProcess.stdout.emit(
+          'data',
+          Buffer.from(`
           {
             "urls": ["https://example.com/page1"],
             "reasoning": "Found page"
           }
-        `));
+        `)
+        );
         mockProcess.emit('close', 0);
       }, 10);
 
@@ -556,10 +609,15 @@ describe('ClaudeClient', () => {
       const promise = client.determineCrawlUrls('<html>test</html>', 'Find all');
 
       setTimeout(() => {
-        mockProcess.stdout.emit('data', Buffer.from(JSON.stringify({
-          urls: 'not an array',
-          reasoning: 'Test',
-        })));
+        mockProcess.stdout.emit(
+          'data',
+          Buffer.from(
+            JSON.stringify({
+              urls: 'not an array',
+              reasoning: 'Test',
+            })
+          )
+        );
         mockProcess.emit('close', 0);
       }, 10);
 
@@ -570,10 +628,15 @@ describe('ClaudeClient', () => {
       const promise = client.determineCrawlUrls('<html>test</html>', 'Find all');
 
       setTimeout(() => {
-        mockProcess.stdout.emit('data', Buffer.from(JSON.stringify({
-          urls: ['https://example.com/page1'],
-          reasoning: 123,
-        })));
+        mockProcess.stdout.emit(
+          'data',
+          Buffer.from(
+            JSON.stringify({
+              urls: ['https://example.com/page1'],
+              reasoning: 123,
+            })
+          )
+        );
         mockProcess.emit('close', 0);
       }, 10);
 
@@ -584,14 +647,19 @@ describe('ClaudeClient', () => {
       const promise = client.determineCrawlUrls('<html>test</html>', 'Find all');
 
       setTimeout(() => {
-        mockProcess.stdout.emit('data', Buffer.from(JSON.stringify({
-          urls: [
-            'https://example.com/page1',
-            'https://example.com/page2',
-            'https://example.com/page3',
-          ],
-          reasoning: 'Found 3 documentation pages',
-        })));
+        mockProcess.stdout.emit(
+          'data',
+          Buffer.from(
+            JSON.stringify({
+              urls: [
+                'https://example.com/page1',
+                'https://example.com/page2',
+                'https://example.com/page3',
+              ],
+              reasoning: 'Found 3 documentation pages',
+            })
+          )
+        );
         mockProcess.emit('close', 0);
       }, 10);
 

package/src/crawl/claude-client.ts

@@ -73,10 +73,7 @@ export class ClaudeClient {
    * @param instruction - Natural language crawl instruction (e.g., "scrape all Getting Started pages")
    * @returns List of URLs to crawl with reasoning
    */
-  async determineCrawlUrls(
-    seedHtml: string,
-    instruction: string,
-  ): Promise<CrawlStrategy> {
+  async determineCrawlUrls(seedHtml: string, instruction: string): Promise<CrawlStrategy> {
     const prompt = `You are analyzing a webpage to determine which pages to crawl based on the user's instruction.
 
 Instruction: ${instruction}
@@ -110,7 +107,7 @@ Return only URLs that are relevant to the instruction. If the instruction mentio
       return { urls: parsed.urls, reasoning: parsed.reasoning };
     } catch (error) {
       throw new Error(
-        `Failed to determine crawl strategy: ${error instanceof Error ? error.message : String(error)}`,
+        `Failed to determine crawl strategy: ${error instanceof Error ? error.message : String(error)}`
       );
     }
   }
@@ -133,7 +130,7 @@ ${this.truncateMarkdown(markdown, 100000)}`;
       return result.trim();
     } catch (error) {
       throw new Error(
-        `Failed to extract content: ${error instanceof Error ? error.message : String(error)}`,
+        `Failed to extract content: ${error instanceof Error ? error.message : String(error)}`
       );
     }
   }
@@ -145,10 +142,7 @@ ${this.truncateMarkdown(markdown, 100000)}`;
    * @param jsonSchema - Optional JSON schema for structured output
    * @returns Claude's response as a string
    */
-  private async callClaude(
-    prompt: string,
-    jsonSchema?: Record<string, unknown>,
-  ): Promise<string> {
+  private async callClaude(prompt: string, jsonSchema?: Record<string, unknown>): Promise<string> {
     return new Promise<string>((resolve, reject) => {
       const args = ['-p'];
 
@@ -193,9 +187,7 @@ ${this.truncateMarkdown(markdown, 100000)}`;
           resolve(stdout.trim());
         } else {
           reject(
-            new Error(
-              `Claude CLI exited with code ${String(code)}${stderr ? `: ${stderr}` : ''}`,
-            ),
+            new Error(`Claude CLI exited with code ${String(code)}${stderr ? `: ${stderr}` : ''}`)
           );
         }
       });
@@ -220,7 +212,7 @@ ${this.truncateMarkdown(markdown, 100000)}`;
     if (html.length <= maxLength) return html;
 
     // Try to keep the beginning (usually has navigation)
-    return html.substring(0, maxLength) + '\n\n[... HTML truncated ...]';
+    return `${html.substring(0, maxLength)}\n\n[... HTML truncated ...]`;
   }
 
   /**
@@ -229,6 +221,6 @@ ${this.truncateMarkdown(markdown, 100000)}`;
   private truncateMarkdown(markdown: string, maxLength: number): string {
     if (markdown.length <= maxLength) return markdown;
 
-    return markdown.substring(0, maxLength) + '\n\n[... content truncated ...]';
+    return `${markdown.substring(0, maxLength)}\n\n[... content truncated ...]`;
   }
 }