@b9g/platform-node 0.1.0

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@b9g/platform-node",
+  "version": "0.1.0",
+  "description": "Node.js platform adapter for Shovel with hot reloading and ESBuild integration",
+  "keywords": [
+    "shovel",
+    "platform",
+    "nodejs",
+    "adapter",
+    "hot-reload",
+    "esbuild"
+  ],
+  "dependencies": {
+    "@b9g/platform": "workspace:*",
+    "@b9g/cache": "workspace:*",
+    "@remix-run/node-fetch-server": "^0.11.0",
+    "@aws-sdk/client-s3": "^3.0.0"
+  },
+  "devDependencies": {
+    "@b9g/libuild": "^0.1.10",
+    "bun-types": "latest",
+    "@types/node": "^18.0.0"
+  },
+  "type": "module",
+  "types": "src/index.d.ts",
+  "module": "src/index.js",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./platform": {
+      "types": "./src/platform.d.ts",
+      "import": "./src/platform.js"
+    },
+    "./platform.js": {
+      "types": "./src/platform.d.ts",
+      "import": "./src/platform.js"
+    },
+    "./package.json": "./package.json",
+    "./index": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./index.js": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    }
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @b9g/platform-node - Node.js platform adapter for Shovel
+ *
+ * Provides hot reloading, ESBuild integration, and optimized caching for Node.js environments.
+ */
+export { NodePlatform, createNodePlatform, type NodePlatformOptions, } from "./platform.js";
+export type { Platform, CacheConfig, StaticConfig, Handler, Server, ServerOptions, } from "@b9g/platform";

package/src/index.js

@@ -0,0 +1,10 @@
+/// <reference types="./index.d.ts" />
+// src/index.ts
+import {
+  NodePlatform,
+  createNodePlatform
+} from "./platform.js";
+export {
+  NodePlatform,
+  createNodePlatform
+};

package/src/platform.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Node.js platform implementation - ServiceWorker entrypoint loader for Node.js
+ *
+ * Handles the complex ESBuild VM system, hot reloading, and module linking
+ * to make ServiceWorker-style apps run in Node.js environments.
+ */
+import { BasePlatform, PlatformConfig, CacheConfig, Handler, Server, ServerOptions, ServiceWorkerOptions, ServiceWorkerInstance } from "@b9g/platform";
+import { CustomCacheStorage } from "@b9g/cache";
+export interface NodePlatformOptions extends PlatformConfig {
+    /** Enable hot reloading (default: true in development) */
+    hotReload?: boolean;
+    /** Port for development server (default: 3000) */
+    port?: number;
+    /** Host for development server (default: localhost) */
+    host?: string;
+    /** Working directory for file resolution */
+    cwd?: string;
+}
+/**
+ * Node.js platform implementation
+ * ServiceWorker entrypoint loader for Node.js with ESBuild VM system
+ */
+export declare class NodePlatform extends BasePlatform {
+    readonly name = "node";
+    private options;
+    private workerManager?;
+    private cacheStorage?;
+    private _dist?;
+    constructor(options?: NodePlatformOptions);
+    /**
+     * Build artifacts filesystem (install-time only)
+     */
+    get distDir(): 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
+     */
+    loadServiceWorker(entrypoint: string, options?: ServiceWorkerOptions): Promise<ServiceWorkerInstance>;
+    /**
+     * Get platform-specific default cache configuration for Node.js
+     */
+    protected getDefaultCacheConfig(): CacheConfig;
+    /**
+     * SUPPORTING UTILITY - Create cache storage optimized for Node.js
+     * Now uses the base class implementation with dynamic loading
+     */
+    createCaches(config?: CacheConfig): Promise<CustomCacheStorage>;
+    /**
+     * SUPPORTING UTILITY - Create HTTP server for Node.js
+     */
+    createServer(handler: Handler, options?: ServerOptions): Server;
+    /**
+     * Get filesystem root for File System Access API
+     */
+    getFileSystemRoot(name?: string): Promise<FileSystemDirectoryHandle>;
+    /**
+     * Dispose of platform resources
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Create a Node.js platform instance
+ */
+export declare function createNodePlatform(options?: NodePlatformOptions): NodePlatform;
+/**
+ * Default export for easy importing
+ */
+export default createNodePlatform;

package/src/platform.js

@@ -0,0 +1,350 @@
+/// <reference types="./platform.d.ts" />
+// src/platform.ts
+import {
+  BasePlatform
+} from "@b9g/platform";
+import { CustomCacheStorage, MemoryCacheManager, PostMessageCache } from "@b9g/cache";
+import { FileSystemRegistry, getFileSystemRoot, NodeFileSystemAdapter, NodeFileSystemDirectoryHandle } 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();
+  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];
+    console.info(
+      `[WorkerManager] Dispatching to worker ${this.currentWorker} of ${this.workers.length}`
+    );
+    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)
+   */
+  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})`);
+  }
+  /**
+   * Graceful shutdown
+   */
+  async terminate() {
+    const terminatePromises = this.workers.map((worker) => worker.terminate());
+    await Promise.allSettled(terminatePromises);
+    await this.memoryCacheManager.dispose();
+    this.workers = [];
+    this.pendingRequests.clear();
+  }
+};
+var NodePlatform = class extends BasePlatform {
+  name = "node";
+  options;
+  workerManager;
+  cacheStorage;
+  _dist;
+  constructor(options = {}) {
+    super(options);
+    this.options = {
+      hotReload: process.env.NODE_ENV !== "production",
+      port: 3e3,
+      host: "localhost",
+      cwd: process.cwd(),
+      ...options
+    };
+    FileSystemRegistry.register("node", new NodeFileSystemAdapter({
+      rootPath: this.options.cwd
+    }));
+  }
+  /**
+   * Build artifacts filesystem (install-time only)
+   */
+  get distDir() {
+    if (!this._dist) {
+      const distPath = Path.resolve(this.options.cwd, "dist");
+      this._dist = new NodeFileSystemDirectoryHandle(distPath);
+    }
+    return this._dist;
+  }
+  /**
+   * 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
+   */
+  async loadServiceWorker(entrypoint, options = {}) {
+    const entryPath = Path.resolve(this.options.cwd, entrypoint);
+    if (!this.cacheStorage) {
+      this.cacheStorage = await this.createCaches(options.caches);
+    }
+    if (this.workerManager) {
+      await this.workerManager.terminate();
+    }
+    const workerCount = options.workerCount || 1;
+    console.info(
+      "[Platform-Node] Creating WorkerManager with entryPath:",
+      entryPath
+    );
+    this.workerManager = new WorkerManager(
+      this.cacheStorage,
+      this.options,
+      workerCount,
+      entryPath
+    );
+    const version = Date.now();
+    await this.workerManager.reloadWorkers(version);
+    const instance = {
+      runtime: this.workerManager,
+      handleRequest: async (request) => {
+        if (!this.workerManager) {
+          throw new Error("WorkerManager not initialized");
+        }
+        return this.workerManager.handleRequest(request);
+      },
+      install: async () => {
+        console.info(
+          "[Platform-Node] ServiceWorker installed via Worker threads"
+        );
+      },
+      activate: async () => {
+        console.info(
+          "[Platform-Node] ServiceWorker activated via Worker threads"
+        );
+      },
+      collectStaticRoutes: async () => {
+        return [];
+      },
+      get ready() {
+        return this.workerManager !== void 0;
+      },
+      dispose: async () => {
+        if (this.workerManager) {
+          await this.workerManager.terminate();
+          this.workerManager = void 0;
+        }
+        console.info("[Platform-Node] ServiceWorker disposed");
+      }
+    };
+    console.info(
+      "[Platform-Node] ServiceWorker loaded with Worker threads and coordinated caches"
+    );
+    return instance;
+  }
+  /**
+   * Get platform-specific default cache configuration for Node.js
+   */
+  getDefaultCacheConfig() {
+    return {
+      pages: { type: "memory" },
+      // PostMessage cache for worker coordination
+      api: { type: "memory" },
+      static: { type: "memory" }
+    };
+  }
+  /**
+   * SUPPORTING UTILITY - Create cache storage optimized for Node.js
+   * Now uses the base class implementation with dynamic loading
+   */
+  async createCaches(config) {
+    const cacheStorage = await super.createCaches(config);
+    return new CustomCacheStorage((name) => {
+      return new PostMessageCache(name, {
+        maxEntries: 1e3,
+        maxSize: 50 * 1024 * 1024
+        // 50MB
+      });
+    });
+  }
+  /**
+   * SUPPORTING UTILITY - Create HTTP server for Node.js
+   */
+  createServer(handler, options = {}) {
+    const port = options.port ?? this.options.port;
+    const host = options.host ?? this.options.host;
+    const httpServer = Http.createServer(async (req, res) => {
+      try {
+        const url = `http://${req.headers.host}${req.url}`;
+        const request = new Request(url, {
+          method: req.method,
+          headers: req.headers,
+          body: req.method !== "GET" && req.method !== "HEAD" ? req : void 0
+        });
+        const response = await handler(request);
+        res.statusCode = response.status;
+        res.statusMessage = response.statusText;
+        response.headers.forEach((value, key) => {
+          res.setHeader(key, value);
+        });
+        if (response.body) {
+          const reader = response.body.getReader();
+          const pump = async () => {
+            const { done, value } = await reader.read();
+            if (done) {
+              res.end();
+            } else {
+              res.write(value);
+              await pump();
+            }
+          };
+          await pump();
+        } else {
+          res.end();
+        }
+      } catch (error) {
+        console.error("[Platform-Node] Request error:", error);
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "text/plain");
+        res.end("Internal Server Error");
+      }
+    });
+    return {
+      listen: () => {
+        return new Promise((resolve2) => {
+          httpServer.listen(port, host, () => {
+            console.info(`\u{1F680} Server running at http://${host}:${port}`);
+            resolve2();
+          });
+        });
+      },
+      close: () => new Promise((resolve2) => {
+        httpServer.close(() => resolve2());
+      }),
+      address: () => ({ port, host })
+    };
+  }
+  /**
+   * Get filesystem root for File System Access API
+   */
+  async getFileSystemRoot(name = "default") {
+    return await getFileSystemRoot(name);
+  }
+  /**
+   * Dispose of platform resources
+   */
+  async dispose() {
+    if (this.workerManager) {
+      await this.workerManager.terminate();
+      this.workerManager = void 0;
+    }
+  }
+};
+function createNodePlatform(options) {
+  return new NodePlatform(options);
+}
+var platform_default = createNodePlatform;
+export {
+  NodePlatform,
+  createNodePlatform,
+  platform_default as default
+};