@b9g/shovel 0.2.0-beta.3 → 0.2.0-beta.5

package/bin/cli.js

@@ -23,10 +23,9 @@ import * as Platform from "@b9g/platform";
 
 // src/esbuild/watcher.ts
 import * as ESBuild from "esbuild";
-import { watch } from "fs";
 import { resolve, dirname as dirname2, join } from "path";
 import { readFileSync } from "fs";
-import { mkdir } from "fs/promises";
+import { mkdir, unlink } from "fs/promises";
 import { assetsPlugin } from "@b9g/assets/plugin";
 
 // src/esbuild/import-meta-plugin.ts
@@ -36,8 +35,8 @@ import { pathToFileURL } from "url";
 function importMetaPlugin() {
   return {
     name: "import-meta-transform",
-    setup(build3) {
-      build3.onLoad({ filter: /\.[jt]sx?$/, namespace: "file" }, async (args) => {
+    setup(build2) {
+      build2.onLoad({ filter: /\.[jt]sx?$/, namespace: "file" }, async (args) => {
         if (args.path.includes("node_modules")) {
           return null;
         }
@@ -82,115 +81,128 @@ function importMetaPlugin() {
 import { getLogger } from "@logtape/logtape";
 var logger = getLogger(["watcher"]);
 var Watcher = class {
-  #watcher;
-  #building;
   #options;
+  #ctx;
+  #initialBuildComplete;
+  #initialBuildResolve;
+  #currentEntrypoint;
+  #previousEntrypoint;
   constructor(options) {
-    this.#building = false;
     this.#options = options;
+    this.#initialBuildComplete = false;
+    this.#currentEntrypoint = "";
+    this.#previousEntrypoint = "";
   }
   /**
    * Start watching and building
+   * @returns Result with success status and the hashed entrypoint path
    */
   async start() {
     const entryPath = resolve(this.#options.entrypoint);
-    await this.#build();
-    const watchDir = dirname2(entryPath);
-    logger.info("Watching for changes", { watchDir });
-    this.#watcher = watch(
-      watchDir,
-      { recursive: true },
-      (_eventType, filename) => {
-        if (filename && (filename.endsWith(".js") || filename.endsWith(".ts") || filename.endsWith(".tsx"))) {
-          const outDir = this.#options.outDir || "dist";
-          if (filename.startsWith(outDir + "/") || filename.startsWith(outDir + "\\")) {
-            return;
+    const outputDir = resolve(this.#options.outDir);
+    const workspaceRoot = this.#findWorkspaceRoot();
+    await mkdir(join(outputDir, "server"), { recursive: true });
+    await mkdir(join(outputDir, "static"), { recursive: true });
+    const initialBuildPromise = new Promise((resolve3) => {
+      this.#initialBuildResolve = resolve3;
+    });
+    this.#ctx = await ESBuild.context({
+      entryPoints: [entryPath],
+      bundle: true,
+      format: "esm",
+      target: "es2022",
+      platform: "node",
+      outdir: `${outputDir}/server`,
+      entryNames: "[name]-[hash]",
+      metafile: true,
+      absWorkingDir: workspaceRoot,
+      plugins: [
+        importMetaPlugin(),
+        assetsPlugin({
+          outDir: outputDir
+        }),
+        // Plugin to detect build completion (works with watch mode)
+        {
+          name: "build-notify",
+          setup: (build2) => {
+            build2.onStart(() => {
+              logger.info("Building", {
+                entrypoint: this.#options.entrypoint
+              });
+            });
+            build2.onEnd(async (result) => {
+              const success = result.errors.length === 0;
+              let outputPath = "";
+              if (result.metafile) {
+                const outputs = Object.keys(result.metafile.outputs);
+                const jsOutput = outputs.find((p) => p.endsWith(".js"));
+                if (jsOutput) {
+                  outputPath = resolve(jsOutput);
+                }
+              }
+              if (success) {
+                logger.info("Build complete", { entrypoint: outputPath });
+                if (this.#currentEntrypoint && this.#currentEntrypoint !== outputPath) {
+                  try {
+                    await unlink(this.#currentEntrypoint);
+                    await unlink(this.#currentEntrypoint + ".map").catch(
+                      () => {
+                      }
+                    );
+                    logger.debug("Cleaned up old build", {
+                      oldEntrypoint: this.#currentEntrypoint
+                    });
+                  } catch {
+                  }
+                }
+              } else {
+                logger.error("Build errors", { errors: result.errors });
+              }
+              this.#previousEntrypoint = this.#currentEntrypoint;
+              this.#currentEntrypoint = outputPath;
+              if (!this.#initialBuildComplete) {
+                this.#initialBuildComplete = true;
+                this.#initialBuildResolve?.({ success, entrypoint: outputPath });
+              } else {
+                this.#options.onBuild?.(success, outputPath);
+              }
+            });
           }
-          this.#debouncedBuild();
         }
-      }
-    );
+      ],
+      sourcemap: "inline",
+      minify: false,
+      treeShaking: true
+    });
+    logger.info("Starting esbuild watch mode");
+    await this.#ctx.watch();
+    return initialBuildPromise;
   }
   /**
-   * Stop watching
+   * Stop watching and dispose of esbuild context
    */
   async stop() {
-    if (this.#watcher) {
-      this.#watcher.close();
-      this.#watcher = void 0;
+    if (this.#ctx) {
+      await this.#ctx.dispose();
+      this.#ctx = void 0;
     }
   }
-  #timeout;
-  #debouncedBuild() {
-    if (this.#timeout) {
-      clearTimeout(this.#timeout);
-    }
-    this.#timeout = setTimeout(() => {
-      this.#build();
-    }, 100);
-  }
-  async #build() {
-    if (this.#building)
-      return;
-    this.#building = true;
-    try {
-      const entryPath = resolve(this.#options.entrypoint);
-      const outputDir = resolve(this.#options.outDir);
-      const version = Date.now();
-      const initialCwd = process.cwd();
-      let workspaceRoot = initialCwd;
-      while (workspaceRoot !== dirname2(workspaceRoot)) {
-        try {
-          const packageJSON = JSON.parse(
-            readFileSync(resolve(workspaceRoot, "package.json"), "utf8")
-          );
-          if (packageJSON.workspaces) {
-            break;
-          }
-        } catch {
+  #findWorkspaceRoot() {
+    const initialCwd = process.cwd();
+    let workspaceRoot = initialCwd;
+    while (workspaceRoot !== dirname2(workspaceRoot)) {
+      try {
+        const packageJSON = JSON.parse(
+          readFileSync(resolve(workspaceRoot, "package.json"), "utf8")
+        );
+        if (packageJSON.workspaces) {
+          return workspaceRoot;
         }
-        workspaceRoot = dirname2(workspaceRoot);
+      } catch {
       }
-      if (workspaceRoot === dirname2(workspaceRoot)) {
-        workspaceRoot = initialCwd;
-      }
-      logger.info("Building", { entryPath });
-      logger.info("Workspace root", { workspaceRoot });
-      await mkdir(join(outputDir, "server"), { recursive: true });
-      await mkdir(join(outputDir, "assets"), { recursive: true });
-      const result = await ESBuild.build({
-        entryPoints: [entryPath],
-        bundle: true,
-        format: "esm",
-        target: "es2022",
-        platform: "node",
-        outfile: `${outputDir}/server/app.js`,
-        packages: "external",
-        absWorkingDir: workspaceRoot,
-        plugins: [
-          importMetaPlugin(),
-          assetsPlugin({
-            outputDir: `${outputDir}/assets`,
-            manifest: `${outputDir}/server/asset-manifest.json`
-          })
-        ],
-        sourcemap: "inline",
-        minify: false,
-        treeShaking: true
-      });
-      if (result.errors.length > 0) {
-        logger.error("Build errors", { errors: result.errors });
-        this.#options.onBuild?.(false, version);
-      } else {
-        logger.info("Build complete", { version });
-        this.#options.onBuild?.(true, version);
-      }
-    } catch (error) {
-      logger.error("Build failed", { error });
-      this.#options.onBuild?.(false, Date.now());
-    } finally {
-      this.#building = false;
+      workspaceRoot = dirname2(workspaceRoot);
     }
+    return initialCwd;
   }
 };
 
@@ -238,20 +250,20 @@ async function developCommand(entrypoint, options) {
     const watcher = new Watcher({
       entrypoint,
       outDir,
-      onBuild: async (success, version) => {
+      onBuild: async (success, builtEntrypoint2) => {
         if (success && serviceWorker) {
-          logger2.info("Reloading Workers", { version });
+          logger2.info("Reloading Workers", { entrypoint: builtEntrypoint2 });
           if (platformInstance && typeof platformInstance.reloadWorkers === "function") {
-            await platformInstance.reloadWorkers(version);
+            await platformInstance.reloadWorkers(builtEntrypoint2);
           }
           logger2.info("Workers reloaded", {});
         }
       }
     });
-    logger2.info("Building", { entrypoint });
-    await watcher.start();
-    logger2.info("Build complete, watching for changes", {});
-    const builtEntrypoint = `${outDir}/server/app.js`;
+    const { success: buildSuccess, entrypoint: builtEntrypoint } = await watcher.start();
+    if (!buildSuccess) {
+      logger2.error("Initial build failed, watching for changes to retry", {});
+    }
     serviceWorker = await platformInstance.loadServiceWorker(builtEntrypoint, {
       hotReload: true,
       workerCount
@@ -277,8 +289,7 @@ async function developCommand(entrypoint, options) {
     process.on("SIGINT", () => shutdown("SIGINT"));
     process.on("SIGTERM", () => shutdown("SIGTERM"));
   } catch (error) {
-    logger2.error("Failed to start development server", {
-      error: error.message,
+    logger2.error("Failed to start development server:\n{stack}", {
       stack: error.stack
     });
     process.exit(1);
@@ -385,8 +396,7 @@ var BUILD_DEFAULTS = {
 };
 var BUILD_STRUCTURE = {
   serverDir: "server",
-  staticDir: "static",
-  assetsDir: "static/assets"
+  staticDir: "static"
 };
 async function buildForProduction({
   entrypoint,
@@ -414,7 +424,7 @@ async function buildForProduction({
   if (verbose) {
     logger5.info("Built app to", { outputDir: buildContext.outputDir });
     logger5.info("Server files", { dir: buildContext.serverDir });
-    logger5.info("Asset files", { dir: buildContext.assetsDir });
+    logger5.info("Static files", { dir: join2(buildContext.outputDir, "static") });
   }
 }
 async function initializeBuild({
@@ -462,7 +472,6 @@ async function initializeBuild({
     await mkdir2(outputDir, { recursive: true });
     await mkdir2(join2(outputDir, BUILD_STRUCTURE.serverDir), { recursive: true });
     await mkdir2(join2(outputDir, BUILD_STRUCTURE.staticDir), { recursive: true });
-    await mkdir2(join2(outputDir, BUILD_STRUCTURE.assetsDir), { recursive: true });
   } catch (error) {
     throw new Error(
       `Failed to create output directory structure: ${error.message}`
@@ -472,7 +481,6 @@ async function initializeBuild({
     entryPath,
     outputDir,
     serverDir: join2(outputDir, BUILD_STRUCTURE.serverDir),
-    assetsDir: join2(outputDir, BUILD_STRUCTURE.assetsDir),
     workspaceRoot,
     platform,
     verbose,
@@ -517,8 +525,8 @@ async function findShovelPackageRoot() {
 }
 async function createBuildConfig({
   entryPath,
+  outputDir,
   serverDir,
-  assetsDir,
   workspaceRoot,
   platform,
   workerCount
@@ -543,11 +551,15 @@ async function createBuildConfig({
         absWorkingDir: workspaceRoot || dirname3(entryPath),
         mainFields: ["module", "main"],
         conditions: ["import", "module"],
+        // Allow user code to import @b9g packages from shovel's packages directory
+        nodePaths: [
+          join2(shovelRoot, "packages"),
+          join2(shovelRoot, "node_modules")
+        ],
         plugins: [
           importMetaPlugin(),
           assetsPlugin2({
-            outputDir: assetsDir,
-            manifest: join2(serverDir, "asset-manifest.json")
+            outDir: outputDir
           })
         ],
         metafile: true,
@@ -614,8 +626,7 @@ async function createBuildConfig({
       plugins: isCloudflare ? [
         importMetaPlugin(),
         assetsPlugin2({
-          outputDir: assetsDir,
-          manifest: join2(serverDir, "asset-manifest.json")
+          outDir: outputDir
         })
       ] : [],
       // Assets already handled in user code build

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/shovel",
-  "version": "0.2.0-beta.3",
+  "version": "0.2.0-beta.5",
   "description": "ServiceWorker-first universal deployment platform. Write ServiceWorker apps once, deploy anywhere (Node/Bun/Cloudflare). Registry-based multi-app orchestration.",
   "license": "MIT",
   "bin": {
@@ -21,30 +21,30 @@
     "source-map": "^0.7.4"
   },
   "devDependencies": {
-    "@b9g/assets": "^0.1.6",
+    "@b9g/assets": "^0.1.12",
     "@b9g/cache": "^0.1.4",
     "@b9g/crank": "^0.7.2",
-    "@b9g/filesystem": "^0.1.5",
-    "@b9g/http-errors": "^0.1.4",
+    "@b9g/filesystem": "^0.1.6",
+    "@b9g/http-errors": "^0.1.5",
     "@b9g/libuild": "^0.1.17",
-    "@b9g/platform": "^0.1.6",
-    "@b9g/platform-bun": "^0.1.6",
-    "@b9g/platform-cloudflare": "^0.1.5",
-    "@b9g/platform-node": "^0.1.8",
-    "@b9g/router": "^0.1.6",
+    "@b9g/platform": "^0.1.9",
+    "@b9g/platform-bun": "^0.1.7",
+    "@b9g/platform-cloudflare": "^0.1.6",
+    "@b9g/platform-node": "^0.1.9",
+    "@b9g/router": "^0.1.7",
     "@types/bun": "^1.2.2",
     "mitata": "^1.0.34",
     "typescript": "^5.7.3"
   },
   "peerDependencies": {
     "@b9g/node-webworker": "^0.1.3",
-    "@b9g/platform": "^0.1.6",
-    "@b9g/platform-node": "^0.1.8",
-    "@b9g/platform-cloudflare": "^0.1.5",
-    "@b9g/platform-bun": "^0.1.6",
+    "@b9g/platform": "^0.1.9",
+    "@b9g/platform-node": "^0.1.9",
+    "@b9g/platform-cloudflare": "^0.1.6",
+    "@b9g/platform-bun": "^0.1.7",
     "@b9g/cache": "^0.1.4",
-    "@b9g/filesystem": "^0.1.5",
-    "@b9g/http-errors": "^0.1.4"
+    "@b9g/filesystem": "^0.1.6",
+    "@b9g/http-errors": "^0.1.5"
   },
   "peerDependenciesMeta": {
     "@b9g/platform": {