create-shibumi 0.2.9 → 0.3.2

package/src/cli.ts

@@ -1,9 +1,23 @@
 #!/usr/bin/env bun
 
 import { cancel, confirm, intro, isCancel, log, outro, select, spinner, text } from "@clack/prompts";
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, readdirSync } from "fs";
 import { join } from "path";
-import { HELP_TEXT, bunVersionProblem, parseArgs, validateName, type TemplateId } from "./args";
+import {
+  AdoptError,
+  adoptProject,
+  dependencyInstall,
+  detectBuildOutput,
+  loadShipStatic,
+} from "./adopt";
+import {
+  HELP_TEXT,
+  bunVersionProblem,
+  parseArgs,
+  validateName,
+  type ParsedArgs,
+  type TemplateId,
+} from "./args";
 import { CreateError, createProject } from "./create";
 
 const VERSION = (
@@ -30,13 +44,216 @@ async function printInstaller(): Promise<never> {
   const bytes = await Bun.file(installer).arrayBuffer();
   const digest = new Bun.CryptoHasher("sha256").update(bytes).digest("hex");
   if (digest !== lock.sha256) {
-    process.stderr.write("Vendored installer does not match its checksum lock; reinstall create-shibumi.\n");
+    process.stderr.write("Packaged installer does not match its checksum lock; reinstall create-shibumi.\n");
     process.exit(1);
   }
   process.stdout.write(readFileSync(installer, "utf8"));
   process.exit(0);
 }
 
+const dim = (value: string) => `\x1b[2m${value}\x1b[22m`;
+const accent = (value: string) => `\x1b[38;5;208m${value}\x1b[0m`;
+
+// Offer the first deployment in the same run. Both entry paths end here, so
+// "Deploy to a VPS now?" means the same thing whether the project was just
+// scaffolded or just adopted.
+async function runShipSetup(dest: string, label: string): Promise<void> {
+  const proc = Bun.spawn(["bun", "run", "ship:setup"], {
+    cwd: dest,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  const code = await proc.exited;
+  if (code !== 0) {
+    process.stderr.write(
+      `ship:setup did not finish. Your project is intact; run "bun ship:setup" ${label} to retry.\n`
+    );
+    process.exit(1);
+  }
+}
+
+/**
+ * `bun create shibumi .`: vendor the Ship client into the project that is
+ * already here instead of scaffolding a new one. Nothing that exists is
+ * overwritten or reinterpreted, and git is never touched.
+ */
+async function adoptExisting(args: ParsedArgs): Promise<void> {
+  const root = process.cwd();
+  const entries = readdirSync(root, { withFileTypes: true }).filter((entry) => entry.name !== ".git");
+  if (entries.length === 0) {
+    process.stderr.write(
+      `Nothing to adopt: this directory is empty.\nRun bun create shibumi <name> to scaffold a new project.\n`
+    );
+    process.exit(2);
+  }
+
+  const packagePath = join(root, "package.json");
+  const pkg = (existsSync(packagePath)
+    ? JSON.parse(readFileSync(packagePath, "utf8"))
+    : {}) as {
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+  };
+  // Adopt generates the static image and only that. A start script means
+  // something runs in the container, which is ship:setup's job: it asks
+  // server-or-static and writes the matching files.
+  if (pkg.scripts?.start) {
+    process.stderr.write(
+      [
+        `This looks like a server app (package.json has a start script).`,
+        `Next: run "bun ship:setup" here; it generates server deployment files.`,
+        `Shipping a static build from a project with a start script? Run "bun ship:setup --static --output-dir <dir>".`,
+        "",
+      ].join("\n")
+    );
+    process.exit(2);
+  }
+  const detected = detectBuildOutput({
+    dependencies: { ...pkg.dependencies, ...pkg.devDependencies },
+    files: entries.filter((entry) => entry.isFile()).map((entry) => entry.name),
+    directories: entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name),
+  });
+  // A flat site at the project root has no directory to serve, and the image
+  // never packages the whole checkout.
+  if (!detected && entries.some((entry) => entry.isFile() && entry.name === "index.html")) {
+    process.stderr.write(
+      [
+        `A static image serves one directory, and index.html is at the project root.`,
+        `Next: move the site into public/ (mkdir public && git mv index.html public/), then run bun create shibumi . again.`,
+        "",
+      ].join("\n")
+    );
+    process.exit(2);
+  }
+  log.info(
+    detected
+      ? `Existing project found (${detected.framework} detected)`
+      : "Existing project found"
+  );
+
+  const interactive = !args.yes;
+  if (interactive) {
+    const proceed = await confirm({
+      message: "Add deploy tooling to this project?",
+      active: "Yes",
+      inactive: "No",
+      initialValue: true,
+    });
+    if (isCancel(proceed) || !proceed) {
+      cancel("Cancelled. Nothing was changed.");
+      process.exit(130);
+    }
+  }
+
+  const ship = await loadShipStatic();
+  let outputDir = detected?.outputDir;
+  if (interactive) {
+    const elsewhere = "";
+    if (detected) {
+      const choice = await select({
+        message: "Built site directory?",
+        options: [
+          { value: detected.outputDir, label: `${detected.outputDir}/ ${dim("(detected)")}` },
+          { value: elsewhere, label: "Somewhere else" },
+        ],
+      });
+      if (isCancel(choice)) exitCancelled();
+      outputDir = choice === elsewhere ? undefined : choice;
+    }
+    if (!outputDir) {
+      const answer = await text({
+        message: "Built site directory?",
+        placeholder: detected?.outputDir ?? "dist",
+        validate: (value) =>
+          value ? ship.staticOutputDirProblem(value) : "Enter the directory your build writes",
+      });
+      if (isCancel(answer)) exitCancelled();
+      outputDir = answer;
+    }
+  }
+  if (!outputDir) {
+    process.stderr.write(
+      `Could not detect the built site directory.\nRun bun create shibumi . in a terminal to choose one.\n`
+    );
+    process.exit(1);
+  }
+
+  let result;
+  try {
+    result = await adoptProject({
+      root,
+      outputDir,
+      buildScript: typeof pkg.scripts?.build === "string" ? "build" : undefined,
+      spa: args.spa,
+      ship,
+    });
+  } catch (err) {
+    if (err instanceof AdoptError) {
+      process.stderr.write(`${err.message}\n`);
+      process.exit(err.exitCode);
+    }
+    throw err;
+  }
+
+  log.success(`Wrote ${result.written.join(", ")}`);
+  if (result.scripts.length > 0) log.success(`Added scripts: ${result.scripts.join(", ")}`);
+  if (result.kept.length > 0) log.info(`Left untouched: ${result.kept.join(", ")}`);
+
+  // The vendored client imports @clack/prompts. A project that already has a
+  // node_modules gets no auto-install, so declaring the dependency is not
+  // enough: every interactive ship command would die on the missing import.
+  if (result.dependency) {
+    const install = dependencyInstall(
+      entries.filter((entry) => entry.isFile()).map((entry) => entry.name)
+    );
+    if (install.manual) {
+      log.warn(
+        `This project has its own lockfile, so nothing was installed here.\nNext: ${install.manual}, then bun ship:setup.`
+      );
+    } else if (!args.install) {
+      log.warn("Run bun install before bun ship:setup; the ship client imports @clack/prompts.");
+    } else {
+      const s = spinner();
+      s.start("Installing @clack/prompts");
+      const proc = Bun.spawn(install.command, {
+        cwd: root,
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "pipe",
+      });
+      const ok = (await proc.exited) === 0;
+      s.stop(ok ? "Installed @clack/prompts" : "Could not install @clack/prompts");
+      if (!ok) log.warn("Run bun install before bun ship:setup; the ship client imports @clack/prompts.");
+    }
+  }
+
+  let deployNow = false;
+  if (interactive) {
+    const answer = await confirm({
+      message: "Deploy to a VPS now?",
+      active: "Yes",
+      inactive: "Later",
+      initialValue: false,
+    });
+    if (isCancel(answer)) exitCancelled();
+    deployNow = answer;
+  }
+  if (deployNow) await runShipSetup(root, "here");
+
+  log.message(
+    [
+      deployNow
+        ? `${accent("next")}  bun ship          ${dim("deploy your first commit")}`
+        : `${accent("next")}  bun ship:setup    ${dim("connect your VPS when you're ready")}`,
+      "",
+      dim(`Deployments serve ${outputDir}/. Review the generated Dockerfile and compose.yaml.`),
+    ].join("\n")
+  );
+  outro(`Docs: ${accent("https://shibumistack.dev/docs")}`);
+}
+
 async function main(): Promise<void> {
   if (process.argv.slice(2).includes("--print-installer")) {
     await printInstaller();
@@ -65,13 +282,20 @@ async function main(): Promise<void> {
   const interactive = !args.yes;
   if (interactive && !process.stdin.isTTY) {
     process.stderr.write(
-      `No interactive terminal. Use --yes with a project name and --template.\n`
+      args.adopt
+        ? `No interactive terminal. Run "bun create shibumi . --yes" to adopt this project with its detected build directory.\n`
+        : `No interactive terminal. Use --yes with a project name and --template.\n`
     );
     process.exit(2);
   }
 
   intro("渋み shibumi");
 
+  if (args.adopt) {
+    await adoptExisting(args);
+    return;
+  }
+
   let name: string;
   if (args.name) {
     name = args.name;
@@ -89,7 +313,6 @@ async function main(): Promise<void> {
   if (args.template) {
     template = args.template;
   } else {
-    const dim = (value: string) => `\x1b[2m${value}\x1b[22m`;
     const detail = (value: string) => `\n    ${dim(value)}`;
     const answer = await select({
       message: "What are you shipping?",
@@ -99,8 +322,8 @@ async function main(): Promise<void> {
           label: `Bun full-stack app ${dim("(recommended)")}${detail("Hono, Alpine, and SQLite with migrations and backups")}`,
         },
         {
-          value: "web" as TemplateId,
-          label: `Bun web app${detail("Hono, Alpine, and Zod; no database")}`,
+          value: "blog" as TemplateId,
+          label: `Blog${detail("with RSS, sitemap, SEO")}`,
         },
         {
           value: "static" as TemplateId,
@@ -110,26 +333,6 @@ async function main(): Promise<void> {
     });
     if (isCancel(answer)) exitCancelled();
     template = answer as TemplateId;
-    if (template === "static") {
-      const start = await select({
-        message: "Start from?",
-        options: [
-          {
-            value: "static" as TemplateId,
-            label: `Plain files${detail("index.html and friends in public/")}`,
-          },
-          {
-            value: "blog" as TemplateId,
-            label: `Astro blog${detail("posts, RSS, sitemap, SEO meta, llms.txt, markdown alternates")}`,
-          },
-        ],
-      });
-      if (isCancel(start)) exitCancelled();
-      template = start as TemplateId;
-      if (template === "static") {
-        log.info("Using a generator? Point bun ship:setup at its output directory later.");
-      }
-    }
   }
 
   let deployNow = false;
@@ -171,7 +374,7 @@ async function main(): Promise<void> {
     if (args.install) log.success("Dependencies installed");
     else log.info("Install skipped; run bun install inside the project");
     if (existsSync(join(result.dest, "scripts", "ship.ts"))) {
-      log.success("Ship client vendored (scripts/ship.ts)");
+      log.success("Deploy script added (scripts/ship.ts)");
     }
   } catch (err) {
     if (err instanceof CreateError) {
@@ -189,19 +392,7 @@ async function main(): Promise<void> {
       scripts?: Record<string, string>;
     };
     if (pkg.scripts?.["ship:setup"] && existsSync(join(dest, "scripts", "ship.ts"))) {
-      const proc = Bun.spawn(["bun", "run", "ship:setup"], {
-        cwd: dest,
-        stdin: "inherit",
-        stdout: "inherit",
-        stderr: "inherit",
-      });
-      const code = await proc.exited;
-      if (code !== 0) {
-        process.stderr.write(
-          `ship:setup did not finish. Your project is intact; run "bun ship:setup" inside ${name} to retry.\n`
-        );
-        process.exit(1);
-      }
+      await runShipSetup(dest, `inside ${name}`);
     } else {
       process.stdout.write(
         `This template has no ship:setup yet. Run "bun ship:setup" inside ${name} once it does.\n`
@@ -209,8 +400,6 @@ async function main(): Promise<void> {
     }
   }
 
-  const accent = (value: string) => `\x1b[38;5;208m${value}\x1b[0m`;
-  const dim = (value: string) => `\x1b[2m${value}\x1b[22m`;
   log.message(
     [
       `${accent("next")}  cd ${name}`,

package/src/templates/blog/agents.md

@@ -10,6 +10,7 @@ bun run build    # astro build to dist/
 bun run check    # astro check (types + templates)
 bun ship:setup   # configure the deploy target (preconfigured: static, dist/, build script)
 bun ship         # verify dist/, build the static image, upload, deploy
+bun ship:webhook # opt in to push-to-deploy; --off reverses it
 ```
 
 ## Routes and templates

package/src/templates/blog/gitignore

@@ -1,4 +1,6 @@
 node_modules/
 dist/
 .astro/
+.env
+.env.*
 .DS_Store

package/src/templates/blog/package.json

@@ -12,7 +12,8 @@
     "ship:setup": "bun scripts/ship.ts --setup --static --output-dir dist --build-script build --no-spa",
     "ship:update": "bun scripts/ship.ts --update",
     "ship:status": "bun scripts/ship.ts --status",
-    "ship:logs": "bun scripts/ship.ts --logs"
+    "ship:logs": "bun scripts/ship.ts --logs",
+    "ship:webhook": "bun scripts/ship.ts --webhook"
   },
   "dependencies": {
     "@astrojs/rss": "4.0.19",

package/src/templates/full-stack/agents.md

@@ -15,6 +15,7 @@ bun db:migrate   # backup (when needed), then apply pending migrations
 bun db:backup    # manual VACUUM INTO backup with sha256 sidecar
 bun db:restore <backup>  # offline restore; stop the app first
 bun ship         # build image, upload, deploy via shibumi-server
+bun ship:webhook # opt in to push-to-deploy; --off reverses it
 bun run shibumi add <name>  # install an extension (auth, email); --dry-run previews
 ```
 

package/src/templates/full-stack/package.json

@@ -15,6 +15,7 @@
     "ship:update": "bun scripts/ship.ts --update",
     "ship:status": "bun scripts/ship.ts --status",
     "ship:logs": "bun scripts/ship.ts --logs",
+    "ship:webhook": "bun scripts/ship.ts --webhook",
     "ship:env": "bun scripts/ship.ts --env",
     "shibumi": "bun scripts/shibumi.ts",
     "shi": "bun scripts/shibumi.ts",