@b9g/platform-node 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-node",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Node.js platform adapter for Shovel with hot reloading and ESBuild integration",
   "keywords": [
     "shovel",
@@ -11,8 +11,8 @@
     "esbuild"
   ],
   "dependencies": {
-    "@b9g/platform": "^0.1.1",
-    "@b9g/cache": "^0.1.1",
+    "@b9g/platform": "workspace:*",
+    "@b9g/cache": "workspace:*",
     "@remix-run/node-fetch-server": "^0.11.0",
     "@aws-sdk/client-s3": "^3.0.0"
   },

package/src/platform.d.ts

@@ -23,14 +23,13 @@ export interface NodePlatformOptions extends PlatformConfig {
 export declare class NodePlatform extends BasePlatform {
     readonly name = "node";
     private options;
-    private workerManager?;
+    private workerPool?;
     private cacheStorage?;
-    private _dist?;
     constructor(options?: NodePlatformOptions);
     /**
-     * Build artifacts filesystem (install-time only)
+     * Get filesystem directory handle
      */
-    get distDir(): FileSystemDirectoryHandle;
+    getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
     /**
      * THE MAIN JOB - Load and run a ServiceWorker-style entrypoint in Node.js
      * Uses Worker threads with coordinated cache storage for isolation and standards compliance
@@ -42,7 +41,7 @@ export declare class NodePlatform extends BasePlatform {
     protected getDefaultCacheConfig(): CacheConfig;
     /**
      * SUPPORTING UTILITY - Create cache storage optimized for Node.js
-     * Now uses the base class implementation with dynamic loading
+     * Uses MemoryCache in main thread, PostMessageCache in workers
      */
     createCaches(config?: CacheConfig): Promise<CustomCacheStorage>;
     /**
@@ -53,6 +52,10 @@ export declare class NodePlatform extends BasePlatform {
      * Get filesystem root for File System Access API
      */
     getFileSystemRoot(name?: string): Promise<FileSystemDirectoryHandle>;
+    /**
+     * Reload workers for hot reloading (called by CLI)
+     */
+    reloadWorkers(version?: number | string): Promise<void>;
     /**
      * Dispose of platform resources
      */

package/src/platform.js

@@ -3,159 +3,42 @@
 import {
   BasePlatform
 } from "@b9g/platform";
-import { CustomCacheStorage, MemoryCacheManager, PostMessageCache } from "@b9g/cache";
-import { FileSystemRegistry, getFileSystemRoot, NodeFileSystemAdapter, NodeFileSystemDirectoryHandle } from "@b9g/filesystem";
+import { WorkerPool } from "@b9g/platform/worker-pool";
+import { CustomCacheStorage, MemoryCache, MemoryCacheManager, PostMessageCache } from "@b9g/cache";
+import { FileSystemRegistry, getDirectoryHandle, LocalBucket } from "@b9g/filesystem";
 import * as Http from "http";
 import * as Path from "path";
-import { Worker } from "worker_threads";
-import { fileURLToPath } from "url";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = Path.dirname(__filename);
-var WorkerManager = class {
-  constructor(cacheStorage, options, workerCount = 1, entrypoint) {
-    this.entrypoint = entrypoint;
-    this.memoryCacheManager = new MemoryCacheManager();
-    this.options = options;
-    console.info(
-      "[WorkerManager] Constructor called with entrypoint:",
-      entrypoint
-    );
-    this.initWorkers(workerCount);
-  }
-  workers = [];
-  currentWorker = 0;
-  requestId = 0;
-  pendingRequests = /* @__PURE__ */ new Map();
+var NodeWorkerPool = class extends WorkerPool {
   memoryCacheManager;
-  options;
-  initWorkers(count) {
-    for (let i = 0; i < count; i++) {
-      this.createWorker();
-    }
-  }
-  createWorker() {
-    let workerScript;
-    try {
-      const workerUrl = import.meta.resolve("@b9g/shovel/worker.js");
-      workerScript = fileURLToPath(workerUrl);
-    } catch (error) {
-      throw new Error(
-        `Could not resolve @b9g/shovel/worker.js: ${error.message}`
-      );
-    }
-    const worker = new Worker(workerScript);
-    worker.on("message", (message) => {
-      if (message.type?.startsWith("cache:")) {
-        this.memoryCacheManager.handleMessage(worker, message);
-      } else {
-        this.handleWorkerMessage(message);
-      }
-    });
-    worker.on("error", (error) => {
-      console.error("[Platform-Node] Worker error:", error);
-    });
-    this.workers.push(worker);
-    return worker;
-  }
-  handleWorkerMessage(message) {
-    if (message.type === "response" && message.requestId) {
-      const pending = this.pendingRequests.get(message.requestId);
-      if (pending) {
-        const response = new Response(message.response.body, {
-          status: message.response.status,
-          statusText: message.response.statusText,
-          headers: message.response.headers
-        });
-        pending.resolve(response);
-        this.pendingRequests.delete(message.requestId);
-      }
-    } else if (message.type === "error" && message.requestId) {
-      const pending = this.pendingRequests.get(message.requestId);
-      if (pending) {
-        pending.reject(new Error(message.error));
-        this.pendingRequests.delete(message.requestId);
-      }
-    } else if (message.type === "ready") {
-      console.info(`[Platform-Node] ServiceWorker ready (v${message.version})`);
-    } else if (message.type === "worker-ready") {
-      console.info("[Platform-Node] Worker initialized");
-    }
-  }
-  /**
-   * Handle HTTP request using round-robin Worker selection
-   */
-  async handleRequest(request) {
-    const worker = this.workers[this.currentWorker];
+  constructor(cacheStorage, poolOptions, appEntrypoint) {
+    super(cacheStorage, poolOptions, appEntrypoint);
+    this.memoryCacheManager = new MemoryCacheManager();
     console.info(
-      `[WorkerManager] Dispatching to worker ${this.currentWorker} of ${this.workers.length}`
+      "[NodeWorkerPool] Initialized with entrypoint:",
+      appEntrypoint
     );
-    this.currentWorker = (this.currentWorker + 1) % this.workers.length;
-    const requestId = ++this.requestId;
-    return new Promise((resolve2, reject) => {
-      this.pendingRequests.set(requestId, { resolve: resolve2, reject });
-      worker.postMessage({
-        type: "request",
-        request: {
-          url: request.url,
-          method: request.method,
-          headers: Object.fromEntries(request.headers.entries()),
-          body: request.body
-        },
-        requestId
-      });
-      setTimeout(() => {
-        if (this.pendingRequests.has(requestId)) {
-          this.pendingRequests.delete(requestId);
-          reject(new Error("Request timeout"));
-        }
-      }, 3e4);
-    });
   }
   /**
-   * Reload ServiceWorker with new version (hot reload simulation)
+   * Handle Node.js-specific cache coordination
    */
-  async reloadWorkers(version = Date.now()) {
-    console.info(`[Platform-Node] Reloading ServiceWorker (v${version})`);
-    const loadPromises = this.workers.map((worker) => {
-      return new Promise((resolve2) => {
-        const handleReady = (message) => {
-          if (message.type === "ready" && message.version === version) {
-            worker.off("message", handleReady);
-            resolve2();
-          }
-        };
-        console.info("[Platform-Node] Sending load message:", {
-          version,
-          entrypoint: this.entrypoint
-        });
-        worker.on("message", handleReady);
-        worker.postMessage({
-          type: "load",
-          version,
-          entrypoint: this.entrypoint
-        });
-      });
-    });
-    await Promise.all(loadPromises);
-    console.info(`[Platform-Node] All Workers reloaded (v${version})`);
+  handleCacheMessage(message) {
+    if (message.type?.startsWith("cache:")) {
+      console.warn("[NodeWorkerPool] Cache coordination not fully implemented in abstraction");
+    }
   }
   /**
-   * Graceful shutdown
+   * Enhanced termination with memory cache cleanup
    */
   async terminate() {
-    const terminatePromises = this.workers.map((worker) => worker.terminate());
-    await Promise.allSettled(terminatePromises);
+    await super.terminate();
     await this.memoryCacheManager.dispose();
-    this.workers = [];
-    this.pendingRequests.clear();
   }
 };
 var NodePlatform = class extends BasePlatform {
   name = "node";
   options;
-  workerManager;
+  workerPool;
   cacheStorage;
-  _dist;
   constructor(options = {}) {
     super(options);
     this.options = {
@@ -165,19 +48,17 @@ var NodePlatform = class extends BasePlatform {
       cwd: process.cwd(),
       ...options
     };
-    FileSystemRegistry.register("node", new NodeFileSystemAdapter({
+    FileSystemRegistry.register("node", new LocalBucket({
       rootPath: this.options.cwd
     }));
   }
   /**
-   * Build artifacts filesystem (install-time only)
+   * Get filesystem directory handle
    */
-  get distDir() {
-    if (!this._dist) {
-      const distPath = Path.resolve(this.options.cwd, "dist");
-      this._dist = new NodeFileSystemDirectoryHandle(distPath);
-    }
-    return this._dist;
+  async getDirectoryHandle(name) {
+    const distPath = Path.resolve(this.options.cwd, "dist");
+    const adapter = new LocalBucket({ rootPath: distPath });
+    return await adapter.getDirectoryHandle(name);
   }
   /**
    * THE MAIN JOB - Load and run a ServiceWorker-style entrypoint in Node.js
@@ -188,29 +69,34 @@ var NodePlatform = class extends BasePlatform {
     if (!this.cacheStorage) {
       this.cacheStorage = await this.createCaches(options.caches);
     }
-    if (this.workerManager) {
-      await this.workerManager.terminate();
+    if (this.workerPool) {
+      await this.workerPool.terminate();
     }
     const workerCount = options.workerCount || 1;
     console.info(
-      "[Platform-Node] Creating WorkerManager with entryPath:",
+      "[Platform-Node] Creating NodeWorkerPool with entryPath:",
       entryPath
     );
-    this.workerManager = new WorkerManager(
+    this.workerPool = new NodeWorkerPool(
       this.cacheStorage,
-      this.options,
-      workerCount,
+      {
+        workerCount,
+        requestTimeout: 3e4,
+        hotReload: this.options.hotReload,
+        cwd: this.options.cwd
+      },
       entryPath
     );
+    await this.workerPool.init();
     const version = Date.now();
-    await this.workerManager.reloadWorkers(version);
+    await this.workerPool.reloadWorkers(version);
     const instance = {
-      runtime: this.workerManager,
+      runtime: this.workerPool,
       handleRequest: async (request) => {
-        if (!this.workerManager) {
-          throw new Error("WorkerManager not initialized");
+        if (!this.workerPool) {
+          throw new Error("NodeWorkerPool not initialized");
         }
-        return this.workerManager.handleRequest(request);
+        return this.workerPool.handleRequest(request);
       },
       install: async () => {
         console.info(
@@ -226,12 +112,12 @@ var NodePlatform = class extends BasePlatform {
         return [];
       },
       get ready() {
-        return this.workerManager !== void 0;
+        return this.workerPool?.ready ?? false;
       },
       dispose: async () => {
-        if (this.workerManager) {
-          await this.workerManager.terminate();
-          this.workerManager = void 0;
+        if (this.workerPool) {
+          await this.workerPool.terminate();
+          this.workerPool = void 0;
         }
         console.info("[Platform-Node] ServiceWorker disposed");
       }
@@ -254,16 +140,24 @@ var NodePlatform = class extends BasePlatform {
   }
   /**
    * SUPPORTING UTILITY - Create cache storage optimized for Node.js
-   * Now uses the base class implementation with dynamic loading
+   * Uses MemoryCache in main thread, PostMessageCache in workers
    */
   async createCaches(config) {
-    const cacheStorage = await super.createCaches(config);
+    const { isMainThread } = await import("worker_threads");
     return new CustomCacheStorage((name) => {
-      return new PostMessageCache(name, {
-        maxEntries: 1e3,
-        maxSize: 50 * 1024 * 1024
-        // 50MB
-      });
+      if (isMainThread) {
+        return new MemoryCache(name, {
+          maxEntries: 1e3,
+          maxAge: 60 * 60 * 1e3
+          // 1 hour
+        });
+      } else {
+        return new PostMessageCache(name, {
+          maxEntries: 1e3,
+          maxAge: 60 * 60 * 1e3
+          // 1 hour
+        });
+      }
     });
   }
   /**
@@ -308,34 +202,55 @@ var NodePlatform = class extends BasePlatform {
         res.end("Internal Server Error");
       }
     });
+    let isListening = false;
     return {
-      listen: () => {
+      async listen() {
         return new Promise((resolve2) => {
           httpServer.listen(port, host, () => {
             console.info(`\u{1F680} Server running at http://${host}:${port}`);
+            isListening = true;
             resolve2();
           });
         });
       },
-      close: () => new Promise((resolve2) => {
-        httpServer.close(() => resolve2());
-      }),
-      address: () => ({ port, host })
+      async close() {
+        return new Promise((resolve2) => {
+          httpServer.close(() => {
+            isListening = false;
+            resolve2();
+          });
+        });
+      },
+      address: () => ({ port, host }),
+      get url() {
+        return `http://${host}:${port}`;
+      },
+      get ready() {
+        return isListening;
+      }
     };
   }
   /**
    * Get filesystem root for File System Access API
    */
   async getFileSystemRoot(name = "default") {
-    return await getFileSystemRoot(name);
+    return await getDirectoryHandle(name);
+  }
+  /**
+   * Reload workers for hot reloading (called by CLI)
+   */
+  async reloadWorkers(version) {
+    if (this.workerPool) {
+      await this.workerPool.reloadWorkers(version);
+    }
   }
   /**
    * Dispose of platform resources
    */
   async dispose() {
-    if (this.workerManager) {
-      await this.workerManager.terminate();
-      this.workerManager = void 0;
+    if (this.workerPool) {
+      await this.workerPool.terminate();
+      this.workerPool = void 0;
     }
   }
 };