@b9g/shovel 0.2.0-beta.2 → 0.2.0-beta.20

package/bin/cli.js

@@ -1,802 +1,78 @@
 #!/usr/bin/env sh
 ':' //; exec "$([ "${npm_config_user_agent#bun/}" != "$npm_config_user_agent" ] && command -v bun || command -v node)" "$0" "$@"
 /// <reference types="./cli.d.ts" />
+import {
+  DEFAULTS,
+  findProjectRoot,
+  loadConfig
+} from "../src/_chunks/chunk-PTLNYIRW.js";
 
 // bin/cli.ts
+import { resolve } from "path";
+import { spawnSync } from "child_process";
+import { configureLogging } from "@b9g/platform/runtime";
 import { Command } from "commander";
 import pkg from "../package.json" with { type: "json" };
-
-// src/esbuild/config.ts
-var DEFAULTS = {
-  SERVER: {
-    PORT: 7777,
-    HOST: "localhost"
-  },
-  WORKERS: 1
-  // Single worker for development - user can override with --workers flag
-};
-
-// src/commands/develop.ts
-import { configure, getConsoleSink, getLogger as getLogger2 } from "@logtape/logtape";
-import { AsyncContext } from "@b9g/async-context";
-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 { assetsPlugin } from "@b9g/assets/plugin";
-
-// src/esbuild/import-meta-plugin.ts
-import { readFile } from "fs/promises";
-import { dirname } from "path";
-import { pathToFileURL } from "url";
-function importMetaPlugin() {
-  return {
-    name: "import-meta-transform",
-    setup(build3) {
-      build3.onLoad({ filter: /\.[jt]sx?$/, namespace: "file" }, async (args) => {
-        if (args.path.includes("node_modules")) {
-          return null;
-        }
-        const contents = await readFile(args.path, "utf8");
-        if (!contents.includes("import.meta.url") && !contents.includes("import.meta.dirname") && !contents.includes("import.meta.filename")) {
-          return null;
-        }
-        const fileUrl = pathToFileURL(args.path).href;
-        const fileDirname = dirname(args.path);
-        const fileFilename = args.path;
-        let transformed = contents;
-        transformed = transformed.replace(
-          /\bimport\.meta\.url\b/g,
-          JSON.stringify(fileUrl)
-        );
-        transformed = transformed.replace(
-          /\bimport\.meta\.dirname\b/g,
-          JSON.stringify(fileDirname)
-        );
-        transformed = transformed.replace(
-          /\bimport\.meta\.filename\b/g,
-          JSON.stringify(fileFilename)
-        );
-        const ext = args.path.split(".").pop();
-        let loader = "js";
-        if (ext === "ts")
-          loader = "ts";
-        else if (ext === "tsx")
-          loader = "tsx";
-        else if (ext === "jsx")
-          loader = "jsx";
-        return {
-          contents: transformed,
-          loader
-        };
-      });
-    }
-  };
-}
-
-// src/esbuild/watcher.ts
-import { getLogger } from "@logtape/logtape";
-var logger = getLogger(["watcher"]);
-var Watcher = class {
-  #watcher;
-  #building;
-  #options;
-  constructor(options) {
-    this.#building = false;
-    this.#options = options;
-  }
-  /**
-   * Start watching and building
-   */
-  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;
-          }
-          this.#debouncedBuild();
-        }
-      }
-    );
-  }
-  /**
-   * Stop watching
-   */
-  async stop() {
-    if (this.#watcher) {
-      this.#watcher.close();
-      this.#watcher = 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 {
-        }
-        workspaceRoot = dirname2(workspaceRoot);
-      }
-      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;
-    }
-  }
-};
-
-// src/commands/develop.ts
-var logger2 = getLogger2(["cli"]);
-await configure({
-  contextLocalStorage: new AsyncContext.Variable(),
-  sinks: {
-    console: getConsoleSink()
-  },
-  loggers: [
-    { category: ["logtape", "meta"], sinks: [] },
-    { category: ["platform-node"], level: "debug", sinks: ["console"] },
-    { category: ["platform-bun"], level: "debug", sinks: ["console"] },
-    { category: ["platform-cloudflare"], level: "debug", sinks: ["console"] },
-    { category: ["cache"], level: "debug", sinks: ["console"] },
-    { category: ["router"], level: "debug", sinks: ["console"] },
-    { category: ["assets"], level: "debug", sinks: ["console"] },
-    { category: ["cli"], level: "debug", sinks: ["console"] },
-    { category: ["watcher"], level: "debug", sinks: ["console"] },
-    { category: ["worker"], level: "debug", sinks: ["console"] }
-  ]
+var projectRoot = findProjectRoot();
+var config = loadConfig(projectRoot);
+async function reifySinks(sinks, baseDir) {
+  const reified = {};
+  for (const [name, sinkConfig] of Object.entries(sinks ?? {})) {
+    const { module: modulePath, export: exportName, ...rest } = sinkConfig;
+    if (modulePath) {
+      const resolvedPath = modulePath.startsWith("./") || modulePath.startsWith("../") ? resolve(baseDir, modulePath) : modulePath;
+      const mod = await import(resolvedPath);
+      const impl = exportName ? mod[exportName] : mod.default;
+      reified[name] = { ...rest, impl };
+    } else if (sinkConfig.impl) {
+      reified[name] = sinkConfig;
+    }
+  }
+  return reified;
+}
+var reifiedSinks = await reifySinks(config.logging?.sinks, projectRoot);
+await configureLogging({
+  sinks: reifiedSinks,
+  loggers: config.logging?.loggers
 });
-async function developCommand(entrypoint, options) {
-  try {
-    const platformName = Platform.resolvePlatform(options);
-    const workerCount = getWorkerCount(options);
-    if (options.verbose) {
-      Platform.displayPlatformInfo(platformName);
-      logger2.info("Worker configuration", { workerCount });
-    }
-    const platformConfig = {
-      hotReload: true,
-      port: parseInt(options.port) || DEFAULTS.SERVER.PORT,
-      host: options.host || DEFAULTS.SERVER.HOST
-    };
-    const platformInstance = await Platform.createPlatform(
-      platformName,
-      platformConfig
-    );
-    logger2.info("Starting development server", {});
-    logger2.info("Workers", { workerCount });
-    let serviceWorker;
-    const outDir = "dist";
-    const watcher = new Watcher({
-      entrypoint,
-      outDir,
-      onBuild: async (success, version) => {
-        if (success && serviceWorker) {
-          logger2.info("Reloading Workers", { version });
-          if (platformInstance && typeof platformInstance.reloadWorkers === "function") {
-            await platformInstance.reloadWorkers(version);
-          }
-          logger2.info("Workers reloaded", {});
-        }
-      }
-    });
-    logger2.info("Building", { entrypoint });
-    await watcher.start();
-    logger2.info("Build complete, watching for changes", {});
-    const builtEntrypoint = `${outDir}/server/app.js`;
-    serviceWorker = await platformInstance.loadServiceWorker(builtEntrypoint, {
-      hotReload: true,
-      workerCount
-    });
-    const server = platformInstance.createServer(serviceWorker.handleRequest, {
-      port: parseInt(options.port) || DEFAULTS.SERVER.PORT,
-      host: options.host || DEFAULTS.SERVER.HOST
-    });
-    await server.listen();
-    logger2.info("Server running", {
-      url: `http://${options.host}:${options.port}`
-    });
-    logger2.info("Serving", { entrypoint });
-    const shutdown = async (signal) => {
-      logger2.info("Shutting down gracefully", { signal });
-      await watcher.stop();
-      await serviceWorker.dispose();
-      await platformInstance.dispose();
-      await server.close();
-      logger2.info("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.message,
-      stack: error.stack
-    });
-    process.exit(1);
-  }
-}
-function getWorkerCount(options) {
-  if (options.workers) {
-    return parseInt(options.workers);
-  }
-  if (process.env.WORKER_COUNT) {
-    return parseInt(process.env.WORKER_COUNT);
-  }
-  return DEFAULTS.WORKERS;
-}
-
-// src/commands/activate.ts
-import { getLogger as getLogger3 } from "@logtape/logtape";
-import * as Platform2 from "@b9g/platform";
-var logger3 = getLogger3(["cli"]);
-async function activateCommand(entrypoint, options) {
-  try {
-    const platformName = Platform2.resolvePlatform(options);
-    const workerCount = getWorkerCount2(options);
-    if (options.verbose) {
-      Platform2.displayPlatformInfo(platformName);
-      logger3.info("Worker configuration", { workerCount });
-    }
-    const platformConfig = {
-      hotReload: false
-    };
-    const platformInstance = await Platform2.createPlatform(
-      platformName,
-      platformConfig
-    );
-    logger3.info("Activating ServiceWorker", {});
-    const serviceWorker = await platformInstance.loadServiceWorker(entrypoint, {
-      hotReload: false,
-      workerCount
+var program = new Command();
+program.name("shovel").description("Shovel CLI").version(pkg.version);
+function checkPlatformReexec(options) {
+  const platform = options.platform ?? config.platform;
+  const isBun = typeof globalThis.Bun !== "undefined";
+  if (platform === "bun" && !isBun) {
+    const result = spawnSync("bun", process.argv.slice(1), { stdio: "inherit" });
+    process.exit(result.status ?? 1);
+  }
+  if (platform === "node" && isBun) {
+    const result = Bun.spawnSync(["node", ...process.argv.slice(1)], {
+      stdout: "inherit",
+      stderr: "inherit",
+      stdin: "inherit"
     });
-    logger3.info(
-      "ServiceWorker activated - check dist/ for generated content",
-      {}
-    );
-    await serviceWorker.dispose();
-    await platformInstance.dispose();
-  } catch (error) {
-    logger3.error("ServiceWorker activation failed", { error: error.message });
-    if (options.verbose) {
-      logger3.error("Stack trace", { stack: error.stack });
-    }
-    process.exit(1);
-  }
-}
-function getWorkerCount2(options) {
-  if (options.workers) {
-    return parseInt(options.workers);
-  }
-  if (process.env.WORKER_COUNT) {
-    return parseInt(process.env.WORKER_COUNT);
+    process.exit(result.exitCode ?? 1);
   }
-  return DEFAULTS.WORKERS;
 }
-
-// src/commands/info.ts
-import { getLogger as getLogger4 } from "@logtape/logtape";
-import { detectRuntime, detectDevelopmentPlatform } from "@b9g/platform";
-var logger4 = getLogger4(["cli"]);
-async function infoCommand() {
-  logger4.info("Shovel Platform Information", {});
-  logger4.info("---", {});
-  logger4.info("Current Runtime", { runtime: detectRuntime() });
-  logger4.info("Default Platform", { platform: detectDevelopmentPlatform() });
-}
-
-// src/commands/build.ts
-import * as ESBuild2 from "esbuild";
-import { resolve as resolve2, join as join2, dirname as dirname3 } from "path";
-import { mkdir as mkdir2, readFile as readFile2, writeFile } from "fs/promises";
-import { fileURLToPath } from "url";
-import { assetsPlugin as assetsPlugin2 } from "@b9g/assets/plugin";
-import { configure as configure2, getConsoleSink as getConsoleSink2, getLogger as getLogger5 } from "@logtape/logtape";
-import { AsyncContext as AsyncContext2 } from "@b9g/async-context";
-await configure2({
-  reset: true,
-  // Allow reconfiguration if already configured
-  contextLocalStorage: new AsyncContext2.Variable(),
-  sinks: {
-    console: getConsoleSink2()
-  },
-  loggers: [
-    { category: ["logtape", "meta"], sinks: [] },
-    { category: ["cli"], level: "info", sinks: ["console"] },
-    { category: ["assets"], level: "info", sinks: ["console"] }
-  ]
-});
-var logger5 = getLogger5(["cli"]);
-var BUILD_DEFAULTS = {
-  format: "esm",
-  target: "es2022",
-  outputFile: "index.js",
-  sourcemap: false,
-  minify: false,
-  treeShaking: true
-};
-var BUILD_STRUCTURE = {
-  serverDir: "server",
-  staticDir: "static",
-  assetsDir: "static/assets"
-};
-async function buildForProduction({
-  entrypoint,
-  outDir,
-  verbose,
-  platform = "node",
-  workerCount = 1
-}) {
-  const buildContext = await initializeBuild({
-    entrypoint,
-    outDir,
-    verbose,
-    platform,
-    workerCount
-  });
-  const buildConfig = await createBuildConfig(buildContext);
-  const result = await ESBuild2.build(buildConfig);
-  if (verbose && result.metafile) {
-    await logBundleAnalysis(result.metafile);
-  }
-  await generatePackageJSON({
-    ...buildContext,
-    entryPath: buildContext.entryPath
-  });
-  if (verbose) {
-    logger5.info("Built app to", { outputDir: buildContext.outputDir });
-    logger5.info("Server files", { dir: buildContext.serverDir });
-    logger5.info("Asset files", { dir: buildContext.assetsDir });
-  }
-}
-async function initializeBuild({
-  entrypoint,
-  outDir,
-  verbose,
-  platform,
-  workerCount = 1
-}) {
-  if (!entrypoint) {
-    throw new Error("Entry point is required");
-  }
-  if (!outDir) {
-    throw new Error("Output directory is required");
-  }
-  if (verbose) {
-    logger5.info("Entry:", { path: entrypoint });
-    logger5.info("Output:", { dir: outDir });
-    logger5.info("Target platform:", { platform });
-  }
-  const entryPath = resolve2(entrypoint);
-  const outputDir = resolve2(outDir);
-  try {
-    const stats = await readFile2(entryPath, "utf8");
-    if (stats.length === 0) {
-      logger5.warn("Entry point is empty", { entryPath });
-    }
-  } catch (error) {
-    throw new Error(`Entry point not found or not accessible: ${entryPath}`);
-  }
-  const validPlatforms = ["node", "bun", "cloudflare", "cloudflare-workers"];
-  if (!validPlatforms.includes(platform)) {
-    throw new Error(
-      `Invalid platform: ${platform}. Valid platforms: ${validPlatforms.join(", ")}`
-    );
-  }
-  const workspaceRoot = await findWorkspaceRoot();
-  if (verbose) {
-    logger5.info("Entry:", { entryPath });
-    logger5.info("Output:", { outputDir });
-    logger5.info("Target platform:", { platform });
-    logger5.info("Workspace root:", { workspaceRoot });
-  }
-  try {
-    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}`
-    );
-  }
-  return {
-    entryPath,
-    outputDir,
-    serverDir: join2(outputDir, BUILD_STRUCTURE.serverDir),
-    assetsDir: join2(outputDir, BUILD_STRUCTURE.assetsDir),
-    workspaceRoot,
-    platform,
-    verbose,
-    workerCount
-  };
-}
-async function findWorkspaceRoot() {
-  let workspaceRoot = process.cwd();
-  while (workspaceRoot !== dirname3(workspaceRoot)) {
-    try {
-      const packageJSON = JSON.parse(
-        await readFile2(resolve2(workspaceRoot, "package.json"), "utf8")
-      );
-      if (packageJSON.workspaces) {
-        return workspaceRoot;
-      }
-    } catch {
-    }
-    workspaceRoot = dirname3(workspaceRoot);
-  }
-  return workspaceRoot;
-}
-async function findShovelPackageRoot() {
-  let currentDir = dirname3(fileURLToPath(import.meta.url));
-  let packageRoot = currentDir;
-  while (packageRoot !== dirname3(packageRoot)) {
-    try {
-      const packageJSONPath = join2(packageRoot, "package.json");
-      const content = await readFile2(packageJSONPath, "utf8");
-      const pkg2 = JSON.parse(content);
-      if (pkg2.name === "@b9g/shovel" || pkg2.name === "shovel") {
-        if (packageRoot.endsWith("/dist") || packageRoot.endsWith("\\dist")) {
-          return dirname3(packageRoot);
-        }
-        return packageRoot;
-      }
-    } catch {
-    }
-    packageRoot = dirname3(packageRoot);
-  }
-  return currentDir;
-}
-async function createBuildConfig({
-  entryPath,
-  serverDir,
-  assetsDir,
-  workspaceRoot,
-  platform,
-  workerCount
-}) {
-  const isCloudflare = platform === "cloudflare" || platform === "cloudflare-workers";
-  try {
-    const virtualEntry = await createVirtualEntry(
-      entryPath,
-      platform,
-      workerCount
-    );
-    const external = ["node:*"];
-    const shovelRoot = await findShovelPackageRoot();
-    if (!isCloudflare) {
-      const userBuildConfig = {
-        entryPoints: [entryPath],
-        bundle: true,
-        format: BUILD_DEFAULTS.format,
-        target: BUILD_DEFAULTS.target,
-        platform: "node",
-        outfile: join2(serverDir, "server.js"),
-        absWorkingDir: workspaceRoot || dirname3(entryPath),
-        mainFields: ["module", "main"],
-        conditions: ["import", "module"],
-        plugins: [
-          importMetaPlugin(),
-          assetsPlugin2({
-            outputDir: assetsDir,
-            manifest: join2(serverDir, "asset-manifest.json")
-          })
-        ],
-        metafile: true,
-        sourcemap: BUILD_DEFAULTS.sourcemap,
-        minify: BUILD_DEFAULTS.minify,
-        treeShaking: BUILD_DEFAULTS.treeShaking,
-        // Node.js doesn't support import.meta.env, so alias it to process.env
-        // Bun supports it natively, so don't replace
-        define: platform === "node" ? { "import.meta.env": "process.env" } : {},
-        external
-      };
-      await ESBuild2.build(userBuildConfig);
-      const runtimeSourcePath = join2(
-        shovelRoot,
-        "packages/platform/dist/src/runtime.js"
-      );
-      const workerDestPath = join2(serverDir, "worker.js");
-      try {
-        await ESBuild2.build({
-          entryPoints: [runtimeSourcePath],
-          bundle: true,
-          format: "esm",
-          target: "es2022",
-          platform: "node",
-          outfile: workerDestPath,
-          external: ["node:*"]
-        });
-      } catch (error) {
-        const installedRuntimePath = join2(
-          shovelRoot,
-          "node_modules/@b9g/platform/dist/src/runtime.js"
-        );
-        await ESBuild2.build({
-          entryPoints: [installedRuntimePath],
-          bundle: true,
-          format: "esm",
-          target: "es2022",
-          platform: "node",
-          outfile: workerDestPath,
-          external: ["node:*"]
-        });
-      }
-    }
-    const buildConfig = {
-      stdin: {
-        contents: virtualEntry,
-        resolveDir: shovelRoot,
-        // Use Shovel root to resolve @b9g packages
-        sourcefile: "virtual-entry.js"
-      },
-      bundle: true,
-      format: BUILD_DEFAULTS.format,
-      target: BUILD_DEFAULTS.target,
-      platform: isCloudflare ? "browser" : "node",
-      // Cloudflare: single-file architecture (server.js contains everything)
-      // Node/Bun: multi-file architecture (index.js is entry, server.js is user code)
-      outfile: join2(
-        serverDir,
-        isCloudflare ? "server.js" : BUILD_DEFAULTS.outputFile
-      ),
-      absWorkingDir: workspaceRoot || dirname3(entryPath),
-      mainFields: ["module", "main"],
-      conditions: ["import", "module"],
-      plugins: isCloudflare ? [
-        importMetaPlugin(),
-        assetsPlugin2({
-          outputDir: assetsDir,
-          manifest: join2(serverDir, "asset-manifest.json")
-        })
-      ] : [],
-      // Assets already handled in user code build
-      metafile: true,
-      sourcemap: BUILD_DEFAULTS.sourcemap,
-      minify: BUILD_DEFAULTS.minify,
-      treeShaking: BUILD_DEFAULTS.treeShaking,
-      // Node.js doesn't support import.meta.env, so alias it to process.env
-      // Bun and Cloudflare support it natively, so don't replace
-      define: platform === "node" ? { "import.meta.env": "process.env" } : {},
-      external
-    };
-    if (isCloudflare) {
-      await configureCloudflareTarget(buildConfig);
-    }
-    return buildConfig;
-  } catch (error) {
-    throw new Error(`Failed to create build configuration: ${error.message}`);
-  }
-}
-async function configureCloudflareTarget(buildConfig) {
-  const { cloudflareWorkerBanner, cloudflareWorkerFooter } = await import("@b9g/platform-cloudflare");
-  buildConfig.platform = "browser";
-  buildConfig.conditions = ["worker", "browser"];
-  buildConfig.banner = { js: cloudflareWorkerBanner };
-  buildConfig.footer = { js: cloudflareWorkerFooter };
-}
-async function createVirtualEntry(userEntryPath, platform, workerCount = 1) {
-  const isCloudflare = platform === "cloudflare" || platform === "cloudflare-workers";
-  if (isCloudflare) {
-    return `
-// Import user's ServiceWorker code
-import "${userEntryPath}";
-`;
-  }
-  return await createWorkerEntry(userEntryPath, workerCount, platform);
-}
-async function createWorkerEntry(userEntryPath, workerCount, platform) {
-  let currentDir = dirname3(fileURLToPath(import.meta.url));
-  let packageRoot = currentDir;
-  while (packageRoot !== dirname3(packageRoot)) {
-    try {
-      const packageJSONPath = join2(packageRoot, "package.json");
-      await readFile2(packageJSONPath, "utf8");
-      break;
-    } catch {
-      packageRoot = dirname3(packageRoot);
-    }
-  }
-  let templatePath = join2(packageRoot, "src/worker-entry.ts");
-  try {
-    await readFile2(templatePath, "utf8");
-  } catch {
-    templatePath = join2(packageRoot, "src/worker-entry.js");
-  }
-  const transpileResult = await ESBuild2.build({
-    entryPoints: [templatePath],
-    bundle: false,
-    // Just transpile - bundling happens in final build
-    format: "esm",
-    target: "es2022",
-    platform: "node",
-    write: false,
-    define: {
-      WORKER_COUNT: JSON.stringify(workerCount),
-      PLATFORM: JSON.stringify(platform)
-    }
-  });
-  return transpileResult.outputFiles[0].text;
-}
-async function logBundleAnalysis(metafile) {
-  try {
-    logger5.info("Bundle analysis:", {});
-    const analysis = await ESBuild2.analyzeMetafile(metafile);
-    logger5.info(analysis, {});
-  } catch (error) {
-    logger5.warn("Failed to analyze bundle", { error: error.message });
-  }
-}
-async function generatePackageJSON({ serverDir, platform, verbose, entryPath }) {
-  const entryDir = dirname3(entryPath);
-  const sourcePackageJsonPath = resolve2(entryDir, "package.json");
-  try {
-    const packageJSONContent = await readFile2(sourcePackageJsonPath, "utf8");
-    try {
-      JSON.parse(packageJSONContent);
-    } catch (parseError) {
-      throw new Error(`Invalid package.json format: ${parseError.message}`);
-    }
-    await writeFile(
-      join2(serverDir, "package.json"),
-      packageJSONContent,
-      "utf8"
-    );
-    if (verbose) {
-      logger5.info("Copied package.json", { serverDir });
-    }
-  } catch (error) {
-    if (verbose) {
-      logger5.warn("Could not copy package.json", { error: error.message });
-    }
-    try {
-      const generatedPackageJson = await generateExecutablePackageJSON(platform);
-      await writeFile(
-        join2(serverDir, "package.json"),
-        JSON.stringify(generatedPackageJson, null, 2),
-        "utf8"
-      );
-      if (verbose) {
-        logger5.info("Generated package.json", { platform });
-        logger5.info("Package.json contents", {
-          contents: JSON.stringify(generatedPackageJson, null, 2)
-        });
-      }
-    } catch (generateError) {
-      if (verbose) {
-        logger5.warn("Could not generate package.json", {
-          error: generateError.message
-        });
-        logger5.warn("Generation error details", { error: generateError });
-      }
-    }
-  }
-}
-async function generateExecutablePackageJSON(platform) {
-  const packageJSON = {
-    name: "shovel-executable",
-    version: "1.0.0",
-    type: "module",
-    private: true,
-    dependencies: {}
-  };
-  const workspaceRoot = await findWorkspaceRoot();
-  const isWorkspaceEnvironment = workspaceRoot !== null;
-  if (isWorkspaceEnvironment) {
-    packageJSON.dependencies = {};
-  } else {
-    switch (platform) {
-      case "node":
-        packageJSON.dependencies["@b9g/platform-node"] = "^0.1.0";
-        break;
-      case "bun":
-        packageJSON.dependencies["@b9g/platform-bun"] = "^0.1.0";
-        break;
-      case "cloudflare":
-        packageJSON.dependencies["@b9g/platform-cloudflare"] = "^0.1.0";
-        break;
-      default:
-        packageJSON.dependencies["@b9g/platform"] = "^0.1.0";
-    }
-    packageJSON.dependencies["@b9g/cache"] = "^0.1.0";
-    packageJSON.dependencies["@b9g/filesystem"] = "^0.1.0";
-  }
-  return packageJSON;
-}
-async function buildCommand(entrypoint, options) {
-  await buildForProduction({
-    entrypoint,
-    outDir: "dist",
-    verbose: options.verbose || false,
-    platform: options.platform || "node",
-    workerCount: options.workers ? parseInt(options.workers, 10) : 1
-  });
-  process.exit(0);
-}
-
-// bin/cli.ts
-var program = new Command();
-program.name("shovel").description("Shovel CLI").version(pkg.version);
 program.command("develop <entrypoint>").description("Start development server with hot reload").option("-p, --port <port>", "Port to listen on", DEFAULTS.SERVER.PORT).option("-h, --host <host>", "Host to bind to", DEFAULTS.SERVER.HOST).option(
   "-w, --workers <count>",
   "Number of workers (default: CPU cores)",
   DEFAULTS.WORKERS
-).option("-v, --verbose", "Verbose logging", false).option("--platform <name>", "Runtime platform (node, cloudflare, bun)").action(developCommand);
-program.command("build <entrypoint>").description("Build app for production").option("-w, --workers <count>", "Worker count (defaults to 1)", void 0).option("--platform <name>", "Runtime platform (node, cloudflare, bun)").action(buildCommand);
-program.command("activate <entrypoint>").description(
-  "Activate ServiceWorker (for static site generation in activate event)"
-).option("-v, --verbose", "Verbose logging", false).option("--platform <name>", "Runtime platform (node, cloudflare, bun)").option(
-  "-w, --workers <count>",
-  "Number of workers",
-  DEFAULTS.WORKERS.toString()
-).action(activateCommand);
-program.command("info").description("Display platform and runtime information").action(infoCommand);
+).option("--platform <name>", "Runtime platform (node, cloudflare, bun)").action(async (entrypoint, options) => {
+  checkPlatformReexec(options);
+  const { developCommand } = await import("../src/_chunks/develop-VHR5FLGQ.js");
+  await developCommand(entrypoint, options, config);
+});
+program.command("build <entrypoint>").description("Build app for production").option("--platform <name>", "Runtime platform (node, cloudflare, bun)").option(
+  "--lifecycle [stage]",
+  "Run ServiceWorker lifecycle after build (install or activate, default: activate)"
+).action(async (entrypoint, options) => {
+  checkPlatformReexec(options);
+  const { buildCommand } = await import("../src/_chunks/build-IWPEM2EW.js");
+  await buildCommand(entrypoint, options, config);
+  process.exit(0);
+});
+program.command("info").description("Display platform and runtime information").action(async () => {
+  const { infoCommand } = await import("../src/_chunks/info-TDUY3FZN.js");
+  await infoCommand();
+});
 program.parse();