@b9g/shovel 0.2.0-beta.10 → 0.2.0-beta.11

package/src/_chunks/develop-A7EU2ZDY.js

@@ -0,0 +1,404 @@
+import {
+  createConfigPlugin,
+  createEntryPlugin,
+  getGitSHA
+} from "./chunk-ADR5RW57.js";
+import {
+  applyJSXOptions,
+  assetsPlugin,
+  importMetaPlugin,
+  loadJSXConfig
+} from "./chunk-JJFM7PO2.js";
+import {
+  DEFAULTS,
+  findProjectRoot
+} from "./chunk-GRAFMTEH.js";
+
+// src/commands/develop.ts
+import { getLogger as getLogger2 } from "@logtape/logtape";
+import * as Platform from "@b9g/platform";
+
+// src/utils/watcher.ts
+import * as ESBuild from "esbuild";
+import { builtinModules } from "node:module";
+import { resolve, join, dirname, basename } from "path";
+import { mkdir } from "fs/promises";
+import { watch, existsSync } from "fs";
+import { getLogger } from "@logtape/logtape";
+var logger = getLogger(["shovel"]);
+var Watcher = class {
+  #options;
+  #ctx;
+  #projectRoot;
+  #initialBuildComplete;
+  #initialBuildResolve;
+  #currentEntrypoint;
+  #configWatchers;
+  #dirWatchers;
+  #userEntryPath;
+  constructor(options) {
+    this.#options = options;
+    this.#projectRoot = findProjectRoot();
+    this.#initialBuildComplete = false;
+    this.#currentEntrypoint = "";
+    this.#configWatchers = [];
+    this.#dirWatchers = /* @__PURE__ */ new Map();
+    this.#userEntryPath = "";
+  }
+  /**
+   * Start watching and building
+   * @returns Result with success status and the hashed entrypoint path
+   */
+  async start() {
+    const entryPath = resolve(this.#projectRoot, this.#options.entrypoint);
+    this.#userEntryPath = entryPath;
+    const outputDir = resolve(this.#projectRoot, this.#options.outDir);
+    await mkdir(join(outputDir, "server"), { recursive: true });
+    const workerEntryWrapper = this.#options.platform.getEntryWrapper(
+      entryPath,
+      { type: "worker", outDir: outputDir }
+    );
+    const jsxOptions = await loadJSXConfig(this.#projectRoot);
+    const initialBuildPromise = new Promise((resolve2) => {
+      this.#initialBuildResolve = resolve2;
+    });
+    const platformESBuildConfig = this.#options.platformESBuildConfig;
+    const external = platformESBuildConfig.external ?? ["node:*"];
+    const buildOptions = {
+      entryPoints: {
+        server: "shovel:entry",
+        config: "shovel:config"
+      },
+      bundle: true,
+      format: "esm",
+      target: "es2022",
+      platform: platformESBuildConfig.platform ?? "node",
+      outdir: `${outputDir}/server`,
+      // Worker gets stable name, server gets hash for cache busting
+      entryNames: "[name]",
+      metafile: true,
+      absWorkingDir: this.#projectRoot,
+      conditions: platformESBuildConfig.conditions ?? ["import", "module"],
+      plugins: [
+        createConfigPlugin(this.#projectRoot, this.#options.outDir, {
+          platformDefaults: this.#options.platform.getDefaults()
+        }),
+        createEntryPlugin(this.#projectRoot, workerEntryWrapper),
+        importMetaPlugin(),
+        assetsPlugin({
+          outDir: outputDir,
+          clientBuild: {
+            jsx: jsxOptions.jsx,
+            jsxFactory: jsxOptions.jsxFactory,
+            jsxFragment: jsxOptions.jsxFragment,
+            jsxImportSource: jsxOptions.jsxImportSource
+          }
+        }),
+        // Plugin to detect build completion (works with watch mode)
+        {
+          name: "build-notify",
+          setup: (build) => {
+            build.onStart(() => {
+              logger.info("Building...");
+            });
+            build.onEnd(async (result) => {
+              let success = result.errors.length === 0;
+              const dynamicImportWarnings = (result.warnings || []).filter(
+                (w) => (w.text.includes("cannot be bundled") || w.text.includes("import() call") || w.text.includes("dynamic import")) && !w.text.includes("./server.js")
+              );
+              if (dynamicImportWarnings.length > 0) {
+                success = false;
+                for (const warning of dynamicImportWarnings) {
+                  const loc = warning.location;
+                  const file = loc?.file || "unknown";
+                  const line = loc?.line || "?";
+                  logger.error(
+                    "Non-analyzable dynamic import at {file}:{line}: {text}",
+                    { file, line, text: warning.text }
+                  );
+                }
+                logger.error(
+                  "Dynamic imports must use literal strings, not variables. For config-driven providers, ensure they are registered in shovel.json."
+                );
+              }
+              if (result.metafile) {
+                const hasNodeWildcard = external.includes("node:*");
+                const allowedSet = new Set(external);
+                const unexpectedExternals = [];
+                for (const path of Object.keys(result.metafile.inputs)) {
+                  if (!path.startsWith("<external>:"))
+                    continue;
+                  const moduleName = path.slice("<external>:".length);
+                  const isAllowed = allowedSet.has(moduleName) || hasNodeWildcard && moduleName.startsWith("node:") || builtinModules.includes(moduleName);
+                  if (!isAllowed && !unexpectedExternals.includes(moduleName)) {
+                    unexpectedExternals.push(moduleName);
+                  }
+                }
+                if (unexpectedExternals.length > 0) {
+                  success = false;
+                  for (const ext of unexpectedExternals) {
+                    logger.error("Unexpected external import: {module}", {
+                      module: ext
+                    });
+                  }
+                  logger.error(
+                    "These modules are not bundled and won't be available at runtime."
+                  );
+                }
+              }
+              let outputPath = "";
+              if (result.metafile) {
+                const outputs = Object.keys(result.metafile.outputs);
+                const serverOutput = outputs.find(
+                  (p) => p.endsWith("server.js")
+                );
+                if (serverOutput) {
+                  outputPath = resolve(this.#projectRoot, serverOutput);
+                }
+              }
+              if (success) {
+                logger.debug("Build complete", { entrypoint: outputPath });
+              } else {
+                logger.error("Build errors: {errors}", { errors: result.errors });
+              }
+              this.#currentEntrypoint = outputPath;
+              if (result.metafile) {
+                this.#updateSourceWatchers(result.metafile);
+              }
+              if (!this.#initialBuildComplete) {
+                this.#initialBuildComplete = true;
+                await new Promise((resolve2) => setTimeout(resolve2, 0));
+                this.#initialBuildResolve?.({ success, entrypoint: outputPath });
+              } else {
+                await this.#options.onBuild?.(success, outputPath);
+              }
+            });
+          }
+        }
+      ],
+      define: {
+        ...platformESBuildConfig.define ?? {},
+        // Inject output directory for [outdir] placeholder resolution
+        __SHOVEL_OUTDIR__: JSON.stringify(outputDir),
+        // Inject git commit SHA for [git] placeholder
+        __SHOVEL_GIT__: JSON.stringify(getGitSHA(this.#projectRoot))
+      },
+      // Mark ./server.js as external so it's imported at runtime (sibling output file)
+      external: [...external, "./server.js"],
+      sourcemap: "inline",
+      minify: false,
+      treeShaking: true
+    };
+    applyJSXOptions(buildOptions, jsxOptions);
+    this.#ctx = await ESBuild.context(buildOptions);
+    logger.debug("Starting esbuild watch mode");
+    await this.#ctx.watch();
+    this.#watchConfigFiles();
+    return initialBuildPromise;
+  }
+  /**
+   * Watch shovel.json and package.json for changes
+   * Triggers rebuild when config changes
+   */
+  #watchConfigFiles() {
+    const configFiles = ["shovel.json", "package.json"];
+    for (const filename of configFiles) {
+      const filepath = join(this.#projectRoot, filename);
+      if (!existsSync(filepath))
+        continue;
+      try {
+        const watcher = watch(filepath, { persistent: false }, (event) => {
+          if (event === "change") {
+            logger.info(`Config changed: ${filename}, rebuilding...`);
+            this.#ctx?.rebuild().catch((err) => {
+              logger.error("Rebuild failed: {error}", { error: err });
+            });
+          }
+        });
+        this.#configWatchers.push(watcher);
+      } catch (err) {
+        logger.warn("Failed to watch {file}: {error}", {
+          file: filename,
+          error: err
+        });
+      }
+    }
+  }
+  /**
+   * Update native directory watchers for source files from metafile.
+   * Uses fs.watch on directories for instant inotify/fsevents detection
+   * as a complement to esbuild's polling-based watch mode.
+   *
+   * Watching directories instead of files handles:
+   * - File deletion and recreation (directory watcher survives)
+   * - Concurrent modifications (one watcher per directory)
+   * - Fewer file descriptors (one per directory vs one per file)
+   */
+  #updateSourceWatchers(metafile) {
+    const newDirFiles = /* @__PURE__ */ new Map();
+    if (this.#userEntryPath) {
+      const entryDir = dirname(this.#userEntryPath);
+      const entryFile = basename(this.#userEntryPath);
+      if (!newDirFiles.has(entryDir)) {
+        newDirFiles.set(entryDir, /* @__PURE__ */ new Set());
+      }
+      newDirFiles.get(entryDir).add(entryFile);
+      logger.debug("Explicitly watching user entry file: {path}", {
+        path: this.#userEntryPath
+      });
+    }
+    for (const inputPath of Object.keys(metafile.inputs)) {
+      if (inputPath.startsWith("<") || inputPath.startsWith("shovel")) {
+        continue;
+      }
+      const fullPath = resolve(this.#projectRoot, inputPath);
+      const dir = dirname(fullPath);
+      const file = basename(fullPath);
+      if (!newDirFiles.has(dir)) {
+        newDirFiles.set(dir, /* @__PURE__ */ new Set());
+      }
+      newDirFiles.get(dir).add(file);
+    }
+    for (const [dir, entry] of this.#dirWatchers) {
+      if (!newDirFiles.has(dir)) {
+        entry.watcher.close();
+        this.#dirWatchers.delete(dir);
+      }
+    }
+    for (const [dir, files] of newDirFiles) {
+      const existing = this.#dirWatchers.get(dir);
+      if (existing) {
+        existing.files = files;
+      } else {
+        if (!existsSync(dir))
+          continue;
+        try {
+          const watcher = watch(dir, { persistent: false }, (event, filename) => {
+            const entry = this.#dirWatchers.get(dir);
+            if (!entry)
+              return;
+            const isTrackedFile = filename ? entry.files.has(filename) : true;
+            if (isTrackedFile) {
+              logger.debug("Native watcher detected change: {file}", {
+                file: filename ? join(dir, filename) : dir
+              });
+              this.#ctx?.rebuild().catch((err) => {
+                logger.error("Rebuild failed: {error}", { error: err });
+              });
+            }
+          });
+          this.#dirWatchers.set(dir, { watcher, files });
+        } catch (err) {
+          logger.debug("Failed to watch directory {dir}: {error}", {
+            dir,
+            error: err
+          });
+        }
+      }
+    }
+    const totalFiles = Array.from(this.#dirWatchers.values()).reduce(
+      (sum, entry) => sum + entry.files.size,
+      0
+    );
+    const watchedDirs = Array.from(this.#dirWatchers.keys());
+    logger.debug(
+      "Watching {fileCount} source files in {dirCount} directories with native fs.watch",
+      { fileCount: totalFiles, dirCount: this.#dirWatchers.size }
+    );
+    logger.debug("Watched directories: {dirs}", {
+      dirs: watchedDirs.slice(0, 5).join(", ") + (watchedDirs.length > 5 ? "..." : "")
+    });
+  }
+  /**
+   * Stop watching and dispose of esbuild context
+   */
+  async stop() {
+    for (const watcher of this.#configWatchers) {
+      watcher.close();
+    }
+    this.#configWatchers = [];
+    for (const entry of this.#dirWatchers.values()) {
+      entry.watcher.close();
+    }
+    this.#dirWatchers.clear();
+    if (this.#ctx) {
+      await this.#ctx.dispose();
+      this.#ctx = void 0;
+    }
+  }
+};
+
+// src/commands/develop.ts
+var logger2 = getLogger2(["shovel"]);
+async function developCommand(entrypoint, options, config) {
+  try {
+    const platformName = Platform.resolvePlatform({ ...options, config });
+    const workerCount = getWorkerCount(options, config);
+    logger2.debug("Platform: {platform}", { platform: platformName });
+    logger2.debug("Worker count: {workerCount}", { workerCount });
+    const platformInstance = await Platform.createPlatform(platformName, {
+      port: parseInt(options.port || String(DEFAULTS.SERVER.PORT), 10),
+      host: options.host || DEFAULTS.SERVER.HOST
+    });
+    const platformESBuildConfig = platformInstance.getESBuildConfig();
+    logger2.info("Starting development server");
+    let serviceWorker;
+    const outDir = "dist";
+    const watcher = new Watcher({
+      entrypoint,
+      outDir,
+      platform: platformInstance,
+      platformESBuildConfig,
+      onBuild: async (success, builtEntrypoint2) => {
+        if (success && serviceWorker) {
+          if (platformInstance && typeof platformInstance.reloadWorkers === "function") {
+            await platformInstance.reloadWorkers(builtEntrypoint2);
+            logger2.info("Reloaded");
+          }
+        }
+      }
+    });
+    const { success: buildSuccess, entrypoint: builtEntrypoint } = await watcher.start();
+    if (!buildSuccess || !builtEntrypoint) {
+      logger2.error("Initial build failed, watching for changes to retry");
+      await new Promise(() => {
+      });
+    }
+    serviceWorker = await platformInstance.loadServiceWorker(builtEntrypoint, {
+      hotReload: true,
+      workerCount
+    });
+    const server = platformInstance.createServer(serviceWorker.handleRequest, {
+      port: parseInt(options.port || String(DEFAULTS.SERVER.PORT), 10),
+      host: options.host || DEFAULTS.SERVER.HOST
+    });
+    await server.listen();
+    logger2.info("Server running at http://{host}:{port}", {
+      host: options.host,
+      port: options.port
+    });
+    const shutdown = async (signal) => {
+      logger2.debug("Shutting down ({signal})", { signal });
+      await watcher.stop();
+      await serviceWorker?.dispose();
+      await platformInstance.dispose();
+      await server.close();
+      logger2.debug("Shutdown complete");
+      process.exit(0);
+    };
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+  } catch (error) {
+    logger2.error("Failed to start development server: {error}", { error });
+    process.exit(1);
+  }
+}
+function getWorkerCount(options, config) {
+  if (options.workers) {
+    return parseInt(options.workers, 10);
+  }
+  return config?.workers ?? DEFAULTS.WORKERS;
+}
+export {
+  developCommand
+};

package/{info-PRYEMZS4.js → src/_chunks/info-TDUY3FZN.js}

@@ -1,7 +1,7 @@
 // src/commands/info.ts
 import { getLogger } from "@logtape/logtape";
 import { detectRuntime, detectDevelopmentPlatform } from "@b9g/platform";
-var logger = getLogger(["cli"]);
+var logger = getLogger(["shovel"]);
 async function infoCommand() {
   logger.info("Shovel Platform Information", {});
   logger.info("---", {});