defuss-ssg 0.6.2 → 0.7.0

package/dist/cli.mjs

@@ -1,20 +1,20 @@
 #!/usr/bin/env node
-import { v as validateProjectDir, b as build } from './vite-DdJcWQGP.mjs';
-import { d as dev, s as serve } from './serve-CTYzPwKQ.mjs';
-import { join, dirname, resolve } from 'node:path';
-import { existsSync, readFileSync } from 'node:fs';
-import { spawn } from 'node:child_process';
+import { r as readConfig, v as validateProjectDir, b as build } from './vite-CSOGjlHB.mjs';
+import { spawnSync, spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdtempSync, writeFileSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { resolve, join, basename, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { d as dev, s as serve } from './serve-BFMU8uCH.mjs';
 import 'fast-glob';
 import 'node:fs/promises';
 import 'defuss/server';
-import 'node:crypto';
 import '@mdx-js/rollup';
 import 'vite';
 import 'defuss-vite';
 import 'node:module';
-import 'node:url';
-import 'node:os';
-import 'esbuild';
+import 'rolldown';
 import 'rehype-katex';
 import 'rehype-stringify';
 import 'remark-frontmatter';
@@ -23,8 +23,243 @@ import 'remark-gfm';
 import 'remark-parse';
 import 'remark-rehype';
 import 'remark-mdx-frontmatter';
+import './path-CjHWUK8o.mjs';
+import 'node:process';
 import 'defuss-express';
 
+const CONTAINER_IMAGE_TAG = "defuss-ssg";
+const CONTAINER_WORKSPACE_DIR = "/workspace";
+const CONTAINER_NODE_MODULES_DIR = `${CONTAINER_WORKSPACE_DIR}/node_modules`;
+const DEFAULT_CONTAINER_PORT = 3e3;
+const GENERATED_DOCKERFILE_NAME = "Dockerfile";
+const createDockerfile = (packageTarballName) => `# syntax=docker/dockerfile:1.7
+
+FROM oven/bun:1.3.9 AS bun
+
+FROM node:24-trixie-slim
+
+WORKDIR /app
+
+ENV NODE_ENV=production
+
+RUN apt-get update \\
+	&& apt-get install -y --no-install-recommends ca-certificates git \\
+	&& git config --global --add url."https://github.com/".insteadOf ssh://git@github.com/ \\
+	&& git config --global --add url."https://github.com/".insteadOf git+ssh://git@github.com/ \\
+	&& git config --global --add url."https://github.com/".insteadOf git@github.com: \\
+	&& rm -rf /var/lib/apt/lists/*
+
+COPY ${packageTarballName} /tmp/${packageTarballName}
+COPY --from=bun /usr/local/bin/bun /usr/local/bin/bun
+RUN ln -sf /usr/local/bin/bun /usr/local/bin/bunx \\
+	&& npm install -g /tmp/${packageTarballName} \\
+	&& rm -f /tmp/${packageTarballName} \\
+	&& npm cache clean --force
+
+ENTRYPOINT ["defuss-ssg"]
+CMD ["dev", "/workspace", "--host", "0.0.0.0", "--port", "3000"]
+`;
+const getPackageRootDir = () => fileURLToPath(new URL("../", import.meta.url));
+const packCurrentPackage = (tempDir) => {
+  const packageRootDir = getPackageRootDir();
+  const result = spawnSync(
+    "npm",
+    ["pack", "--json", "--pack-destination", tempDir],
+    {
+      cwd: packageRootDir,
+      encoding: "utf8",
+      shell: process.platform === "win32"
+    }
+  );
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(
+      result.stderr || "Failed to pack the current defuss-ssg package."
+    );
+  }
+  const output = JSON.parse(result.stdout);
+  const tarballName = output.at(0)?.filename;
+  if (!tarballName) {
+    throw new Error("npm pack did not return a package tarball name.");
+  }
+  return tarballName;
+};
+const getNodeModulesVolumeName = (projectDir) => {
+  const safeBaseName = basename(projectDir).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project";
+  const hash = createHash("sha256").update(projectDir).digest("hex").slice(0, 12);
+  return `defuss-ssg-node-modules-${safeBaseName}-${hash}`;
+};
+const hasCommand = (command) => {
+  const result = spawnSync(command, ["--version"], {
+    stdio: "ignore",
+    shell: process.platform === "win32"
+  });
+  return !result.error && result.status === 0;
+};
+const resolveContainerRuntime = async (projectDir, debug) => {
+  const configuredRuntime = (await readConfig(projectDir, debug)).containerRuntime;
+  if (configuredRuntime) {
+    if (!hasCommand(configuredRuntime)) {
+      throw new Error(
+        `Configured containerRuntime "${configuredRuntime}" is not available on PATH.`
+      );
+    }
+    return configuredRuntime;
+  }
+  if (hasCommand("docker")) {
+    return "docker";
+  }
+  if (hasCommand("podman")) {
+    return "podman";
+  }
+  throw new Error(
+    "Neither docker nor podman is available on PATH. Install one of them or set containerRuntime in config.ts."
+  );
+};
+const runContainerRuntime = (runtime, args, label, cwd) => {
+  const result = spawnSync(runtime, args, {
+    cwd,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(
+      `${runtime} ${args.join(" ")} failed while ${label} with code ${result.status ?? "unknown"}`
+    );
+  }
+};
+const hasPublishArgs = (dockerArgs) => {
+  for (let index = 0; index < dockerArgs.length; index += 1) {
+    const arg = dockerArgs[index];
+    if (arg === "-p" || arg === "-P" || arg === "--publish" || arg === "--publish-all" || arg.startsWith("--publish=")) {
+      return true;
+    }
+  }
+  return false;
+};
+const extractHostNetworkArgs = (dockerArgs) => {
+  const remainingArgs = [];
+  let hostNetworkRequested = false;
+  for (let index = 0; index < dockerArgs.length; index += 1) {
+    const arg = dockerArgs[index];
+    if (arg === "--net=host" || arg === "--network=host") {
+      hostNetworkRequested = true;
+      continue;
+    }
+    if ((arg === "--net" || arg === "--network") && dockerArgs[index + 1] === "host") {
+      hostNetworkRequested = true;
+      index += 1;
+      continue;
+    }
+    remainingArgs.push(arg);
+  }
+  return {
+    remainingArgs,
+    hostNetworkRequested
+  };
+};
+const getInnerCommand = (command) => command.slice("docker-".length);
+const createInnerArgs = ({
+  command,
+  debug,
+  host,
+  port,
+  multicore,
+  skipSetup
+}) => {
+  const innerCommand = getInnerCommand(command);
+  const innerArgs = [innerCommand, CONTAINER_WORKSPACE_DIR];
+  if (debug) {
+    innerArgs.push("--debug");
+  }
+  if (innerCommand === "serve" && multicore) {
+    innerArgs.push("--multicore");
+  }
+  if (skipSetup) {
+    innerArgs.push("--skip-setup");
+  }
+  if (innerCommand === "dev" || innerCommand === "serve") {
+    const selectedHost = host ?? "0.0.0.0";
+    const selectedPort = port ?? DEFAULT_CONTAINER_PORT;
+    innerArgs.push("--host", selectedHost, "--port", String(selectedPort));
+    return { innerArgs, selectedPort };
+  }
+  return {
+    innerArgs,
+    selectedPort: port
+  };
+};
+const runContainerCommand = async ({
+  command,
+  projectDir,
+  debug = false,
+  host,
+  port,
+  multicore = false,
+  skipSetup = false,
+  dockerArgs
+}) => {
+  const resolvedProjectDir = resolve(projectDir);
+  const runtime = await resolveContainerRuntime(resolvedProjectDir, debug);
+  const { remainingArgs, hostNetworkRequested } = extractHostNetworkArgs(dockerArgs);
+  const useHostNetwork = hostNetworkRequested && process.platform === "linux";
+  const tempDir = mkdtempSync(join(tmpdir(), "defuss-ssg-container-"));
+  const volumeName = getNodeModulesVolumeName(resolvedProjectDir);
+  const dockerfilePath = join(tempDir, GENERATED_DOCKERFILE_NAME);
+  const { innerArgs, selectedPort } = createInnerArgs({
+    command,
+    debug,
+    host,
+    port,
+    multicore,
+    skipSetup
+  });
+  const packageTarballName = packCurrentPackage(tempDir);
+  writeFileSync(dockerfilePath, createDockerfile(packageTarballName), "utf8");
+  try {
+    console.log(`Using ${runtime} for containerized ${getInnerCommand(command)}.`);
+    if (hostNetworkRequested && !useHostNetwork) {
+      console.warn(
+        `Ignoring --network host on ${process.platform}; using published ports for localhost access instead.`
+      );
+    }
+    runContainerRuntime(
+      runtime,
+      ["build", "-t", CONTAINER_IMAGE_TAG, "-f", GENERATED_DOCKERFILE_NAME, tempDir],
+      "building the defuss-ssg container image",
+      tempDir
+    );
+    const runArgs = [
+      "run",
+      "--rm",
+      ...remainingArgs,
+      "-v",
+      `${resolvedProjectDir}:${CONTAINER_WORKSPACE_DIR}`,
+      "-v",
+      `${volumeName}:${CONTAINER_NODE_MODULES_DIR}`
+    ];
+    if (useHostNetwork) {
+      runArgs.push("--network", "host");
+    }
+    if ((selectedPort ?? 0) > 0 && (getInnerCommand(command) === "dev" || getInnerCommand(command) === "serve") && !hasPublishArgs(remainingArgs) && !useHostNetwork) {
+      runArgs.push("-p", `${selectedPort}:${selectedPort}`);
+    }
+    runArgs.push(CONTAINER_IMAGE_TAG, ...innerArgs);
+    runContainerRuntime(
+      runtime,
+      runArgs,
+      `running ${command} for ${resolvedProjectDir}`
+    );
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+};
+
 const canResolve = (dep, dir) => {
   let current = dir;
   while (true) {
@@ -38,7 +273,7 @@ const canResolve = (dep, dir) => {
 const runInstall = (cmd, args, cwd, env) => new Promise((resolve, reject) => {
   const child = spawn(cmd, args, {
     cwd,
-    shell: true,
+    shell: process.platform === "win32",
     stdio: ["inherit", "pipe", "pipe"],
     env: env ?? process.env
   });
@@ -48,11 +283,11 @@ const runInstall = (cmd, args, cwd, env) => new Promise((resolve, reject) => {
     lastLines.push(line);
     if (lastLines.length > 3) lastLines.shift();
     if (process.stdout.isTTY) {
-      for (let i = 0; i < printedLines; i++) {
+      for (let index = 0; index < printedLines; index += 1) {
         process.stdout.write("\x1B[1A\x1B[2K");
       }
-      for (const l of lastLines) {
-        process.stdout.write(`${l}
+      for (const outputLine of lastLines) {
+        process.stdout.write(`${outputLine}
 `);
       }
       printedLines = lastLines.length;
@@ -62,22 +297,49 @@ const runInstall = (cmd, args, cwd, env) => new Promise((resolve, reject) => {
     }
   };
   const handleData = (chunk) => {
-    const lines = chunk.toString().split(/\r\n|\n|\r/).filter((l) => l.trim().length > 0);
+    const lines = chunk.toString().split(/\r\n|\n|\r/).filter((line) => line.trim().length > 0);
     for (const line of lines) pushLine(line);
   };
   child.stdout?.on("data", handleData);
   child.stderr?.on("data", handleData);
   child.on("error", reject);
   child.on("close", (code) => {
-    if (code === 0) resolve();
-    else
-      reject(
-        new Error(
-          `${cmd} ${args.join(" ")} exited with code ${code ?? "unknown"}`
-        )
-      );
+    if (code === 0) {
+      resolve();
+      return;
+    }
+    reject(
+      new Error(
+        `${cmd} ${args.join(" ")} exited with code ${code ?? "unknown"}`
+      )
+    );
   });
 });
+const getInstallCommand = (pm, projectDir) => {
+  if (pm === "bun") {
+    return {
+      cmd: "bun",
+      args: ["install", "--no-cache"],
+      env: { ...process.env, BUN_WORKSPACE_ROOT: projectDir }
+    };
+  }
+  if (pm === "yarn") {
+    return {
+      cmd: "corepack",
+      args: ["yarn", "install"]
+    };
+  }
+  if (pm === "pnpm") {
+    return {
+      cmd: "corepack",
+      args: ["pnpm", "install"]
+    };
+  }
+  return {
+    cmd: "npm",
+    args: ["install"]
+  };
+};
 const setup = async (projectDir) => {
   const projectDirStatus = validateProjectDir(projectDir);
   if (projectDirStatus.code !== "OK") return projectDirStatus;
@@ -110,22 +372,19 @@ const setup = async (projectDir) => {
     ...packageJson.dependencies,
     ...packageJson.devDependencies
   };
-  const depNames = Object.keys(allDeps).filter(
-    (d) => d !== "defuss-ssg"
-    // skip self-reference (we're already running)
-  );
-  const allResolvable = depNames.length === 0 || depNames.every((d) => canResolve(d, projectDir));
+  const depNames = Object.keys(allDeps);
+  const allResolvable = depNames.length === 0 || depNames.every((dependency) => canResolve(dependency, projectDir));
   if (allResolvable) {
-    console.log(`All dependencies already available - skipping install.`);
+    console.log("All dependencies already available - skipping install.");
     return { code: "OK", message: "Setup completed (deps already available)" };
   }
   console.log(`Setting up project in ${projectDir} using ${pm}...`);
   if (pm === "bun") {
     try {
       await new Promise((resolve, reject) => {
-        const child = spawn(pm, ["pm", "trust", "esbuild"], {
+        const child = spawn("bun", ["pm", "trust", "esbuild"], {
           cwd: projectDir,
-          shell: true,
+          shell: process.platform === "win32",
           stdio: "ignore",
           env: { ...process.env, BUN_WORKSPACE_ROOT: projectDir }
         });
@@ -136,46 +395,142 @@ const setup = async (projectDir) => {
     }
   }
   try {
-    const bunEnv = { ...process.env, BUN_WORKSPACE_ROOT: projectDir };
+    const installCommand = getInstallCommand(pm, projectDir);
     await runInstall(
-      pm,
-      pm === "bun" ? ["install", "--no-cache", "--linker", "isolated"] : ["install"],
+      installCommand.cmd,
+      installCommand.args,
       projectDir,
-      pm === "bun" ? bunEnv : void 0
+      installCommand.env
     );
     console.log("Dependencies installed successfully.");
+    return { code: "OK", message: "Setup completed successfully" };
   } catch (error) {
-    if (pm === "bun") {
-      console.warn(
-        `Warning: ${error.message}
-Falling back to npm install...`
-      );
-      try {
-        await runInstall("npm", ["install"], projectDir);
-        console.log("Dependencies installed successfully via npm.");
-      } catch (npmError) {
-        console.warn(
-          `Warning: npm install also failed: ${npmError.message}
-Continuing anyway - dependencies may already be available.`
-        );
+    return {
+      code: "INSTALL_FAILED",
+      message: `Failed to install dependencies with ${pm}: ${error.message}`
+    };
+  }
+};
+
+const usage = `Usage: defuss-ssg [dev|build|serve|docker-dev|docker-build|docker-serve] [folder] [options]
+  No args           => dev .
+  Single path       => dev <path>
+  Single command    => <command> .
+  Command + folder  => <command> <folder>
+  Flags:
+    --debug, -d
+    --multicore
+    --port, -p <number>
+    --host, -H <host>
+		--skip-setup
+		--docker-args <args...>`;
+const isTruthy = (value) => {
+  if (!value) return false;
+  return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+};
+const isDefussWorkerProcess = () => typeof process.env.DEFUSS_WORKER_INDEX === "string";
+const readFlagValue = (args, index, flag) => {
+  const next = args[index + 1];
+  if (!next || next.startsWith("-")) {
+    throw new Error(`Missing value for ${flag}`);
+  }
+  return next;
+};
+const parsePort = (value) => {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid port: ${value}`);
+  }
+  return port;
+};
+const parseCliArgs = (args) => {
+  const dockerArgsIndex = args.indexOf("--docker-args");
+  const cliArgs = dockerArgsIndex === -1 ? args : args.slice(0, dockerArgsIndex);
+  const dockerArgs = dockerArgsIndex === -1 ? [] : args.slice(dockerArgsIndex + 1);
+  let debug = false;
+  let multicore = false;
+  let skipSetup = isTruthy(process.env.DEFUSS_SSG_SKIP_SETUP) || isDefussWorkerProcess();
+  let port;
+  let host;
+  const positional = [];
+  for (let index = 0; index < cliArgs.length; index += 1) {
+    const arg = cliArgs[index];
+    if (arg === "--debug" || arg === "-d") {
+      debug = true;
+      continue;
+    }
+    if (arg === "--multicore") {
+      multicore = true;
+      continue;
+    }
+    if (arg === "--skip-setup" || arg === "--no-setup") {
+      skipSetup = true;
+      continue;
+    }
+    if (arg === "--port" || arg === "-p") {
+      port = parsePort(readFlagValue(args, index, arg));
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--port=")) {
+      port = parsePort(arg.slice("--port=".length));
+      continue;
+    }
+    if (arg === "--host" || arg === "-H") {
+      host = readFlagValue(args, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--host=")) {
+      host = arg.slice("--host=".length);
+      if (!host) {
+        throw new Error("Missing value for --host");
       }
-    } else {
-      console.warn(
-        `Warning: ${error.message}
-Continuing anyway - dependencies may already be available.`
-      );
+      continue;
     }
+    positional.push(arg);
   }
-  return { code: "OK", message: "Setup completed successfully" };
+  return {
+    debug,
+    dockerArgs,
+    multicore,
+    skipSetup,
+    port,
+    host,
+    positional
+  };
 };
-
 (async () => {
   const args = process.argv.slice(2);
-  const debug = args.includes("--debug") || args.includes("-d");
-  const multicore = args.includes("--multicore");
-  const positional = args.filter((a) => !a.startsWith("-"));
-  const commands = /* @__PURE__ */ new Set(["dev", "build", "serve"]);
-  const usage = "Usage: defuss-ssg [dev|build|serve] [folder]\n  No args           => dev .\n  Single path       => dev <path>\n  Single command    => <command> .\n  Command + folder  => <command> <folder>\n  Flags: [--debug] [--multicore]";
+  const commands = /* @__PURE__ */ new Set([
+    "dev",
+    "build",
+    "serve",
+    "docker-dev",
+    "docker-build",
+    "docker-serve"
+  ]);
+  const containerCommands = /* @__PURE__ */ new Set([
+    "docker-dev",
+    "docker-build",
+    "docker-serve"
+  ]);
+  let debug;
+  let dockerArgs;
+  let multicore;
+  let skipSetup;
+  let port;
+  let host;
+  let positional;
+  try {
+    ({ debug, dockerArgs, multicore, skipSetup, port, host, positional } = parseCliArgs(args));
+  } catch (error) {
+    console.error(
+      `${error instanceof Error ? error.message : "Invalid CLI arguments"}
+${usage}`
+    );
+    process.exit(1);
+  }
   let command;
   let folder;
   if (positional.length === 0) {
@@ -202,26 +557,70 @@ Continuing anyway - dependencies may already be available.`
     process.exit(1);
   }
   const projectDir = resolve(folder);
-  await setup(projectDir);
+  const workerProcess = isDefussWorkerProcess();
+  const isContainerCommand = containerCommands.has(command);
+  if (!isContainerCommand && dockerArgs.length > 0) {
+    console.error(
+      `--docker-args can only be used with docker-dev, docker-build, or docker-serve.
+${usage}`
+    );
+    process.exit(1);
+  }
+  if (isContainerCommand) {
+    await runContainerCommand({
+      command,
+      projectDir,
+      debug,
+      host,
+      port,
+      multicore,
+      skipSetup,
+      dockerArgs
+    });
+    return;
+  }
+  if (skipSetup) {
+    if (!workerProcess) {
+      console.log(
+        `Skipping dependency setup for ${folder} (prepared environment).`
+      );
+    }
+  } else {
+    const setupStatus = await setup(projectDir);
+    if (setupStatus.code !== "OK") {
+      console.error(setupStatus.message);
+      process.exit(1);
+    }
+  }
   if (command === "dev") {
-    console.log(`Starting Vite dev server for ${folder}...`);
+    if (!workerProcess) {
+      console.log(`Starting Vite dev server for ${folder}...`);
+    }
     await dev({
       projectDir,
       debug,
+      host,
+      port,
       writeDevOutput: true
     });
   } else if (command === "build") {
-    console.log(`Building ${folder}...`);
+    if (!workerProcess) {
+      console.log(`Building ${folder}...`);
+    }
     await build({
       projectDir,
       debug,
       mode: "build"
     });
   } else if (command === "serve") {
-    console.log(`Serving built output for ${folder}...`);
+    if (!workerProcess) {
+      console.log(`Serving built output for ${folder}...`);
+    }
     await serve({
       projectDir,
       debug,
+      host,
+      port,
       workers: multicore ? "auto" : 1
     });
   } else {