create-riebeckite 0.0.15 → 0.0.16

package/dist/src/arguments.d.ts

@@ -5,6 +5,7 @@ export type CreateRiebeckiteOptions = {
     readonly preset: ScaffoldPresetName;
     readonly listPresets: boolean;
     readonly githubActions: boolean;
+    readonly cloudflareWorkers: boolean;
     readonly contentRepository?: string;
     readonly siteRepository?: string;
 };

package/dist/src/index.js

@@ -71,6 +71,7 @@ function parseArguments(arguments_) {
     preset: preset ?? "starter",
     listPresets,
     githubActions,
+    cloudflareWorkers: false,
     contentRepository,
     siteRepository
   };
@@ -90,6 +91,7 @@ import {
   scaffoldPresets as scaffoldPresets2
 } from "@riebeckite/honox";
 var DEFAULT_DIRECTORY = "my-riebeckite-site";
+var DEFAULT_INTERACTIVE_DEPLOYMENT = "none";
 function interactiveAnswersToOptions(answers) {
   const external = answers.contentSource === "external";
   return {
@@ -98,6 +100,7 @@ function interactiveAnswersToOptions(answers) {
     preset: answers.preset,
     listPresets: false,
     githubActions: external || answers.deployment === "github-actions",
+    cloudflareWorkers: !external && answers.deployment === "cloudflare",
     contentRepository: external ? answers.contentRepository : void 0,
     siteRepository: external ? answers.siteRepository : void 0
   };
@@ -131,6 +134,9 @@ async function promptInteractiveAnswers() {
   if (isCancel(contentSource)) return null;
   let answers;
   if (contentSource === "external") {
+    log.info(
+      "Separate repositories use GitHub Actions so content updates can trigger site deployments."
+    );
     const contentRepository = await text({
       message: "Content repository",
       placeholder: "OWNER/notes"
@@ -152,11 +158,17 @@ async function promptInteractiveAnswers() {
   } else {
     const deployment = await select({
       message: "Set up deployment?",
-      initialValue: "github-actions",
+      initialValue: DEFAULT_INTERACTIVE_DEPLOYMENT,
       options: [
+        {
+          value: "cloudflare",
+          label: "Cloudflare Workers",
+          hint: "Publish from this machine"
+        },
         {
           value: "github-actions",
-          label: "GitHub Actions + Cloudflare Workers"
+          label: "GitHub Actions",
+          hint: "Deploy on every push"
         },
         { value: "none", label: "Not now" }
       ]
@@ -167,51 +179,149 @@ async function promptInteractiveAnswers() {
   log.step("Creating Riebeckite site...");
   return answers;
 }
+async function promptDeployNow() {
+  const answer = await select({
+    message: "Deploy now?",
+    initialValue: "yes",
+    options: [
+      { value: "yes", label: "Yes" },
+      { value: "later", label: "Later" }
+    ]
+  });
+  if (isCancel(answer)) return false;
+  return answer === "yes";
+}
 function capitalize(value) {
   return value.charAt(0).toUpperCase() + value.slice(1);
 }
 
-// src/index.ts
-async function runCreateRiebeckite(arguments_) {
-  let options;
-  if (arguments_.length === 0) {
-    const answers = await promptInteractiveAnswers();
-    if (answers === null) {
-      console.log("Operation cancelled.");
-      return;
-    }
-    options = interactiveAnswersToOptions(answers);
-  } else {
-    try {
-      options = parseArguments(arguments_);
-    } catch (error) {
-      console.error(error instanceof Error ? error.message : String(error));
-      process.exitCode = 1;
-      return;
+// src/package-manager.ts
+import { PACKAGE_MANAGER } from "@riebeckite/honox";
+function packageManagerCommands(name = PACKAGE_MANAGER) {
+  if (name === "pnpm") {
+    return {
+      name,
+      install: { command: "pnpm", args: ["install"], label: "pnpm install" },
+      build: { command: "pnpm", args: ["build"], label: "pnpm build" },
+      deploy: {
+        command: "pnpm",
+        args: ["exec", "riebeckite", "deploy"],
+        label: "pnpm exec riebeckite deploy"
+      }
+    };
+  }
+  return {
+    name: "npm",
+    install: { command: "npm", args: ["install"], label: "npm install" },
+    build: { command: "npm", args: ["run", "build"], label: "npm run build" },
+    deploy: {
+      command: "npm",
+      args: ["exec", "riebeckite", "deploy"],
+      label: "npm exec riebeckite deploy"
     }
+  };
+}
+
+// src/publish.ts
+var DeploymentFailure = class extends Error {
+  phase;
+  constructor(phase, message) {
+    super(message);
+    this.name = "DeploymentFailure";
+    this.phase = phase;
+  }
+};
+async function installDependencies(directory, commands, run) {
+  await runCommand("install", commands.install, directory, run);
+}
+async function buildAndDeploy(directory, commands, run) {
+  await runCommand("build", commands.build, directory, run);
+  await runCommand("deploy", commands.deploy, directory, run);
+}
+function formatCloudflareNextSteps(relativeDirectory, commands) {
+  const lines = ["Next steps:"];
+  if (relativeDirectory !== ".") {
+    lines.push(`  cd ${relativeDirectory}`);
+  }
+  lines.push(`  ${commands.build.label}`);
+  lines.push(`  ${commands.deploy.label}`);
+  return lines.join("\n");
+}
+function formatDeploymentFailure(relativeDirectory, commands, failure) {
+  const lines = [
+    "Project created successfully.",
+    deploymentFailureSummary(failure.phase),
+    failure.message,
+    "You can retry with:"
+  ];
+  if (relativeDirectory !== ".") {
+    lines.push(`  cd ${relativeDirectory}`);
+  }
+  if (failure.phase === "install") {
+    lines.push(`  ${commands.install.label}`);
+  }
+  lines.push(`  ${commands.build.label}`);
+  lines.push(`  ${commands.deploy.label}`);
+  return lines.join("\n");
+}
+function deploymentFailureSummary(phase) {
+  if (phase === "install") return "Installing dependencies failed.";
+  if (phase === "build") return "Build failed.";
+  return "Deployment failed.";
+}
+async function runCommand(phase, command, directory, run) {
+  let exitCode;
+  try {
+    exitCode = await run(command.command, command.args, directory);
+  } catch (error) {
+    throw new DeploymentFailure(
+      phase,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  if (exitCode !== 0) {
+    throw new DeploymentFailure(
+      phase,
+      `${command.label} exited with code ${exitCode}.`
+    );
   }
+}
+
+// src/run-commands.ts
+import { spawn } from "node:child_process";
+function spawnCommand(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, [...args], {
+      cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => resolve(code ?? 1));
+  });
+}
+
+// src/index.ts
+async function runCreateRiebeckite(arguments_) {
+  const resolved = await resolveOptions(arguments_);
+  if (resolved === null) return;
+  const { options, interactive } = resolved;
   if (options.listPresets) {
     printPresets();
     return;
   }
   const targetDirectory = path.resolve(process.cwd(), options.directory);
+  let result;
   try {
-    const result = await scaffoldRiebeckiteSite({
+    result = await scaffoldRiebeckiteSite({
       targetDirectory,
       overwrite: options.force,
       preset: options.preset,
       githubActions: options.githubActions,
+      cloudflareWorkers: options.cloudflareWorkers,
       contentRepository: options.contentRepository,
       siteRepository: options.siteRepository
     });
-    const relative = path.relative(process.cwd(), result.targetDirectory) || ".";
-    console.log(`Created a ${options.preset} Riebeckite site in ${relative}`);
-    console.log("");
-    const externalContent = options.contentRepository !== void 0;
-    const editFile = !externalContent && result.files.includes("content/index.md") ? "content/index.md" : void 0;
-    console.log(
-      formatScaffoldNextSteps(relative, { editFile, externalContent })
-    );
   } catch (error) {
     if (error instanceof ScaffoldSiteError) {
       console.error(error.message);
@@ -220,6 +330,68 @@ async function runCreateRiebeckite(arguments_) {
     }
     throw error;
   }
+  const relative = path.relative(process.cwd(), result.targetDirectory) || ".";
+  console.log(`Created a ${options.preset} Riebeckite site in ${relative}`);
+  console.log("");
+  if (interactive && options.cloudflareWorkers) {
+    await publishCloudflareSite(targetDirectory, relative);
+    return;
+  }
+  printScaffoldNextSteps(options, result, relative);
+}
+async function resolveOptions(arguments_) {
+  if (arguments_.length === 0) {
+    const answers = await promptInteractiveAnswers();
+    if (answers === null) {
+      console.log("Operation cancelled.");
+      return null;
+    }
+    return { options: interactiveAnswersToOptions(answers), interactive: true };
+  }
+  try {
+    return { options: parseArguments(arguments_), interactive: false };
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+    return null;
+  }
+}
+function printScaffoldNextSteps(options, result, relative) {
+  const externalContent = options.contentRepository !== void 0;
+  const editFile = !externalContent && result.files.includes("content/index.md") ? "content/index.md" : void 0;
+  console.log(formatScaffoldNextSteps(relative, { editFile, externalContent }));
+}
+async function publishCloudflareSite(targetDirectory, relative) {
+  const commands = packageManagerCommands();
+  console.log(`Installing dependencies with ${commands.name}...`);
+  try {
+    await installDependencies(targetDirectory, commands, spawnCommand);
+  } catch (error) {
+    if (!(error instanceof DeploymentFailure)) throw error;
+    reportDeploymentFailure(error, relative);
+    return;
+  }
+  const deployNow = await promptDeployNow();
+  if (!deployNow) {
+    console.log("");
+    console.log(formatCloudflareNextSteps(relative, commands));
+    return;
+  }
+  try {
+    await buildAndDeploy(targetDirectory, commands, spawnCommand);
+  } catch (error) {
+    if (!(error instanceof DeploymentFailure)) throw error;
+    reportDeploymentFailure(error, relative);
+    return;
+  }
+  console.log("");
+  console.log("Deployment complete.");
+}
+function reportDeploymentFailure(error, relative) {
+  const commands = packageManagerCommands();
+  console.error("");
+  console.error(formatDeploymentFailure(relative, commands, error));
+  process.exitCode = 1;
 }
 export {
   runCreateRiebeckite

package/dist/src/interactive.d.ts

@@ -1,7 +1,8 @@
 import { type ScaffoldPresetName } from "@riebeckite/honox";
 import type { CreateRiebeckiteOptions } from "./arguments.js";
+export declare const DEFAULT_INTERACTIVE_DEPLOYMENT: InteractiveDeployment;
 export type InteractiveContentSource = "local" | "external";
-export type InteractiveDeployment = "github-actions" | "none";
+export type InteractiveDeployment = "cloudflare" | "github-actions" | "none";
 export type InteractiveAnswers = {
     readonly directory: string;
     readonly preset: ScaffoldPresetName;
@@ -22,3 +23,4 @@ export declare function interactiveAnswersToOptions(answers: InteractiveAnswers)
  * `owner/repository` shape is validated by the existing scaffold.
  */
 export declare function promptInteractiveAnswers(): Promise<InteractiveAnswers | null>;
+export declare function promptDeployNow(): Promise<boolean>;

package/dist/src/package-manager.d.ts

@@ -0,0 +1,13 @@
+export type PackageManagerName = "npm" | "pnpm";
+export type PackageManagerCommand = {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly label: string;
+};
+export type PackageManagerCommands = {
+    readonly name: PackageManagerName;
+    readonly install: PackageManagerCommand;
+    readonly build: PackageManagerCommand;
+    readonly deploy: PackageManagerCommand;
+};
+export declare function packageManagerCommands(name?: PackageManagerName): PackageManagerCommands;

package/dist/src/publish.d.ts

@@ -0,0 +1,11 @@
+import type { PackageManagerCommands } from "./package-manager.js";
+import type { CommandRunner } from "./run-commands.js";
+export type DeploymentPhase = "install" | "build" | "deploy";
+export declare class DeploymentFailure extends Error {
+    readonly phase: DeploymentPhase;
+    constructor(phase: DeploymentPhase, message: string);
+}
+export declare function installDependencies(directory: string, commands: PackageManagerCommands, run: CommandRunner): Promise<void>;
+export declare function buildAndDeploy(directory: string, commands: PackageManagerCommands, run: CommandRunner): Promise<void>;
+export declare function formatCloudflareNextSteps(relativeDirectory: string, commands: PackageManagerCommands): string;
+export declare function formatDeploymentFailure(relativeDirectory: string, commands: PackageManagerCommands, failure: DeploymentFailure): string;

package/dist/src/run-commands.d.ts

@@ -0,0 +1,2 @@
+export type CommandRunner = (command: string, args: readonly string[], cwd: string) => Promise<number>;
+export declare function spawnCommand(command: string, args: readonly string[], cwd: string): Promise<number>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-riebeckite",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.8.1",
-    "@riebeckite/honox": "0.0.15"
+    "@riebeckite/honox": "0.0.16"
   },
   "repository": {
     "type": "git",