create-svc 0.1.2 → 0.1.4

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "create-svc",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Bun-authored CLI to scaffold Go Cloud Run services with Chi, ConnectRPC, Vault, and Cloudflare examples.",
   "module": "index.ts",
   "type": "module",
   "license": "MIT",
   "bin": {
-    "create-svc": "./bin/create-svc.mjs",
-    "create-service": "./bin/create-svc.mjs"
+    "create-svc": "bin/create-svc.mjs",
+    "create-service": "bin/create-svc.mjs"
   },
   "files": [
     "bin",
@@ -44,6 +44,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.2.0",
+    "@google-cloud/billing": "^5.1.1",
+    "@google-cloud/resource-manager": "^6.2.1",
+    "@neondatabase/api-client": "^2.7.1",
     "picocolors": "^1.1.1"
   }
 }

package/src/cli.ts

@@ -1,29 +1,60 @@
-import { cancel, confirm, intro, isCancel, log, note, outro, spinner, text } from "@clack/prompts";
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  log,
+  note,
+  outro,
+  select,
+  spinner,
+  text,
+} from "@clack/prompts";
 import pc from "picocolors";
 import { basename, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { runPostScaffoldFlow } from "./post-scaffold";
+import { listOpenBillingAccounts, listAccessibleProjects, type BillingAccount, type GcpProject } from "./gcp";
+import { discoverNeonDefaults } from "./neon";
+import {
+  BILLING_ACCOUNT_DEFAULT,
+  FRAMEWORKS_BY_RUNTIME,
+  QUOTA_PROJECT_DEFAULT,
+  buildCreateProjectLabel,
+  buildGcpProjectOptions,
+  deriveDefaults,
+  slugify,
+  type Framework,
+  type GcpProjectMode,
+  type Runtime,
+} from "./naming";
 import { scaffoldProject, type ScaffoldConfig } from "./scaffold";
 
 type ParsedArgs = {
   directory?: string;
-  modulePath?: string;
-  projectId?: string;
-  region?: string;
+  runtime?: Runtime;
+  framework?: Framework;
+  gcpProjectMode?: GcpProjectMode;
+  gcpProject?: string;
   githubRepo?: string;
-  vaultAddr?: string;
-  vaultSecretPath?: string;
-  vaultSecretKey?: string;
-  cloudflareZoneId?: string;
-  bufModule?: string;
+  region?: string;
+  billingAccount?: string;
+  quotaProjectId?: string;
+  autoDeploy?: boolean;
   yes: boolean;
   help: boolean;
 };
 
+type DiscoveryState = {
+  projects: GcpProject[];
+  billingAccounts: BillingAccount[];
+  neonProjectId?: string;
+  neonBaseBranchId?: string;
+  neonBaseBranchName?: string;
+  warnings: string[];
+};
+
 const DEFAULT_REGION = "us-west1";
-const DEFAULT_VAULT_ADDR = "https://vault.anmho.com";
-const DEFAULT_VAULT_SECRET_PATH = "provider/cloudflare-api-token";
-const DEFAULT_VAULT_SECRET_KEY = "value";
-const DEFAULT_CLOUDFLARE_ZONE_ID = "893c2371cc222826de6e00583f4902ea";
 
 export async function run(argv: string[]) {
   const args = parseArgs(argv);
@@ -32,7 +63,7 @@ export async function run(argv: string[]) {
     return;
   }
 
-  intro(`${pc.bold("create-service")} ${pc.dim("Cloud Run scaffold")}`);
+  intro(`${pc.bold("create-svc")} ${pc.dim("Cloud Run scaffold")}`);
 
   const config = await resolveConfig(args);
   const targetDir = resolve(process.cwd(), config.directory);
@@ -40,8 +71,10 @@ export async function run(argv: string[]) {
   note(
     [
       `${pc.bold("Output")}: ${targetDir}`,
-      `${pc.bold("Module")}: ${config.modulePath}`,
-      `${pc.bold("Deploy")}: public Cloud Run service with Vault-backed Cloudflare DNS CRUD`,
+      `${pc.bold("Runtime")}: ${config.runtime} + ${config.framework}`,
+      `${pc.bold("Project")}: ${config.gcpProjectMode === "create_new" ? "create" : "use"} ${config.gcpProjectName} (${config.gcpProject})`,
+      `${pc.bold("GitHub")}: ${config.githubRepo}`,
+      `${pc.bold("Neon")}: ${config.neonProjectId || "(set later)"} / ${config.neonBaseBranchName || "(set later)"}`,
     ].join("\n"),
     "Scaffold"
   );
@@ -51,12 +84,26 @@ export async function run(argv: string[]) {
   await scaffoldProject(config);
   buildSpinner.stop("Project files generated");
 
+  const shouldRunPostScaffoldFlow = Boolean(process.stdout.isTTY && process.stdin.isTTY && (config.createGithubRepo || config.autoDeploy));
+  if (shouldRunPostScaffoldFlow) {
+    const automationSpinner = spinner();
+    automationSpinner.start("Running post-scaffold automation");
+    try {
+      const result = await runPostScaffoldFlow(config, targetDir);
+      automationSpinner.stop(result.message);
+    } catch (error) {
+      automationSpinner.stop("Post-scaffold automation skipped");
+      log.warn(error instanceof Error ? error.message : String(error));
+    }
+  }
+
   outro(
     [
       `Next: ${pc.cyan(`cd ${config.directory}`)}`,
       `Local dev: ${pc.cyan("bun dev")}`,
-      `Generate stubs: ${pc.cyan("bun gen")}`,
-      `First deploy: set ${pc.cyan("BOOTSTRAP_VAULT_ROLE_ID")} and ${pc.cyan("BOOTSTRAP_VAULT_SECRET_ID")}, then run ${pc.cyan("bun run deploy")}`,
+      `Bootstrap: ${pc.cyan("bun run bootstrap")}`,
+      `Deploy: ${pc.cyan("bun run deploy")}`,
+      `Personal env: ${pc.cyan(`bun run deploy -- --environment personal --name ${config.serviceName}`)}`,
     ].join("\n")
   );
 }
@@ -97,93 +144,98 @@ function parseArgs(argv: string[]): ParsedArgs {
       continue;
     }
 
-    if (token === "--module") {
-      parsed.modulePath = readValue();
+    if (token === "--runtime") {
+      parsed.runtime = readValue() as Runtime;
       continue;
     }
 
-    if (token.startsWith("--module=")) {
-      parsed.modulePath = token.slice("--module=".length);
+    if (token.startsWith("--runtime=")) {
+      parsed.runtime = token.slice("--runtime=".length) as Runtime;
       continue;
     }
 
-    if (token === "--project-id") {
-      parsed.projectId = readValue();
+    if (token === "--framework") {
+      parsed.framework = readValue() as Framework;
       continue;
     }
 
-    if (token.startsWith("--project-id=")) {
-      parsed.projectId = token.slice("--project-id=".length);
+    if (token.startsWith("--framework=")) {
+      parsed.framework = token.slice("--framework=".length) as Framework;
       continue;
     }
 
-    if (token === "--region") {
-      parsed.region = readValue();
+    if (token === "--project-mode") {
+      parsed.gcpProjectMode = readValue() as GcpProjectMode;
       continue;
     }
 
-    if (token.startsWith("--region=")) {
-      parsed.region = token.slice("--region=".length);
+    if (token.startsWith("--project-mode=")) {
+      parsed.gcpProjectMode = token.slice("--project-mode=".length) as GcpProjectMode;
       continue;
     }
 
-    if (token === "--github-repo") {
-      parsed.githubRepo = readValue();
+    if (token === "--project-id" || token === "--gcp-project") {
+      parsed.gcpProject = readValue();
       continue;
     }
 
-    if (token.startsWith("--github-repo=")) {
-      parsed.githubRepo = token.slice("--github-repo=".length);
+    if (token.startsWith("--project-id=")) {
+      parsed.gcpProject = token.slice("--project-id=".length);
       continue;
     }
 
-    if (token === "--vault-addr") {
-      parsed.vaultAddr = readValue();
+    if (token.startsWith("--gcp-project=")) {
+      parsed.gcpProject = token.slice("--gcp-project=".length);
       continue;
     }
 
-    if (token.startsWith("--vault-addr=")) {
-      parsed.vaultAddr = token.slice("--vault-addr=".length);
+    if (token === "--github-repo") {
+      parsed.githubRepo = readValue();
       continue;
     }
 
-    if (token === "--vault-secret-path") {
-      parsed.vaultSecretPath = readValue();
+    if (token.startsWith("--github-repo=")) {
+      parsed.githubRepo = token.slice("--github-repo=".length);
       continue;
     }
 
-    if (token.startsWith("--vault-secret-path=")) {
-      parsed.vaultSecretPath = token.slice("--vault-secret-path=".length);
+    if (token === "--region") {
+      parsed.region = readValue();
+      continue;
+    }
+
+    if (token.startsWith("--region=")) {
+      parsed.region = token.slice("--region=".length);
       continue;
     }
 
-    if (token === "--vault-secret-key") {
-      parsed.vaultSecretKey = readValue();
+    if (token === "--billing-account") {
+      parsed.billingAccount = readValue();
       continue;
     }
 
-    if (token.startsWith("--vault-secret-key=")) {
-      parsed.vaultSecretKey = token.slice("--vault-secret-key=".length);
+    if (token.startsWith("--billing-account=")) {
+      parsed.billingAccount = token.slice("--billing-account=".length);
       continue;
     }
 
-    if (token === "--cloudflare-zone-id") {
-      parsed.cloudflareZoneId = readValue();
+    if (token === "--quota-project") {
+      parsed.quotaProjectId = readValue();
       continue;
     }
 
-    if (token.startsWith("--cloudflare-zone-id=")) {
-      parsed.cloudflareZoneId = token.slice("--cloudflare-zone-id=".length);
+    if (token.startsWith("--quota-project=")) {
+      parsed.quotaProjectId = token.slice("--quota-project=".length);
       continue;
     }
 
-    if (token === "--buf-module") {
-      parsed.bufModule = readValue();
+    if (token === "--auto-deploy") {
+      parsed.autoDeploy = true;
       continue;
     }
 
-    if (token.startsWith("--buf-module=")) {
-      parsed.bufModule = token.slice("--buf-module=".length);
+    if (token === "--no-auto-deploy") {
+      parsed.autoDeploy = false;
       continue;
     }
 
@@ -193,36 +245,22 @@ function parseArgs(argv: string[]): ParsedArgs {
   return parsed;
 }
 
-async function resolveConfig(args: ParsedArgs): Promise<ScaffoldConfig> {
-  const inferredName = slugify(basename(args.directory ?? "dns-api"));
+export async function resolveConfig(args: ParsedArgs): Promise<ScaffoldConfig> {
+  const inferredName = slugify(basename(args.directory ?? "my-service"));
   const serviceName = args.yes
     ? inferredName
     : await promptText("Service name", inferredName, (value) => slugify(value).length > 0 || "Service name is required");
 
-  const directory = args.directory ?? serviceName;
-  const githubRepo = args.githubRepo ?? `anmho/${serviceName}`;
-  const modulePath = args.modulePath ?? `github.com/${githubRepo}`;
-  const projectId = args.projectId ?? (args.yes ? "my-gcp-project" : "");
+  const defaults = deriveDefaults(serviceName);
+  const discovery = await discoverCloudInputs(serviceName);
+  const runtime = await resolveRuntime(args);
+  const framework = await resolveFramework(args, runtime);
+  const gcpSelection = await resolveGcpSelection(args, defaults, discovery);
+  const githubRepo = args.githubRepo ?? defaults.githubRepo;
   const region = args.region ?? DEFAULT_REGION;
-  const vaultAddr = args.vaultAddr ?? DEFAULT_VAULT_ADDR;
-  const vaultSecretPath = args.vaultSecretPath ?? DEFAULT_VAULT_SECRET_PATH;
-  const vaultSecretKey = args.vaultSecretKey ?? DEFAULT_VAULT_SECRET_KEY;
-  const cloudflareZoneId = args.cloudflareZoneId ?? DEFAULT_CLOUDFLARE_ZONE_ID;
-  const bufModule = args.bufModule ?? `buf.build/${githubRepo}`;
-
-  const confirmedProjectId = projectId || (await promptText("GCP project ID", "my-gcp-project", (value) => value.trim().length > 0 || "Project ID is required"));
-  const confirmedModulePath = args.yes
-    ? modulePath
-    : await promptText("Go module path", modulePath, (value) => value.trim().length > 0 || "Module path is required");
-  const confirmedGithubRepo = args.yes
-    ? githubRepo
-    : await promptText("GitHub repo", githubRepo, (value) => value.includes("/") || "Use owner/repo format");
-  const confirmedRegion = args.yes
-    ? region
-    : await promptText("Cloud Run region", region, (value) => value.trim().length > 0 || "Region is required");
-  const confirmedBufModule = args.yes
-    ? bufModule
-    : await promptText("Buf module", bufModule, (value) => value.trim().length > 0 || "Buf module is required");
+  const billingAccount = chooseBillingAccount(args.billingAccount, discovery.billingAccounts);
+  const autoDeploy = resolveAutoDeploy(args.autoDeploy);
+  const directory = args.directory ?? serviceName;
 
   if (!args.yes) {
     const okay = await confirm({
@@ -235,22 +273,208 @@ async function resolveConfig(args: ParsedArgs): Promise<ScaffoldConfig> {
     }
   }
 
+  for (const warning of discovery.warnings) {
+    log.warn(warning);
+  }
+
   return {
     directory,
     serviceName,
-    modulePath: confirmedModulePath,
-    projectId: confirmedProjectId,
-    region: confirmedRegion,
-    githubRepo: confirmedGithubRepo,
-    vaultAddr,
-    vaultSecretPath,
-    vaultSecretKey,
-    cloudflareZoneId,
-    bufModule: confirmedBufModule,
+    runtime,
+    framework,
+    region,
+    gcpProjectMode: gcpSelection.mode,
+    gcpProject: gcpSelection.projectId,
+    gcpProjectName: gcpSelection.projectName,
+    billingAccount,
+    quotaProjectId: args.quotaProjectId ?? QUOTA_PROJECT_DEFAULT,
+    githubRepo,
+    githubVisibility: "public",
+    createGithubRepo: true,
+    autoDeploy,
+    neonProjectId: discovery.neonProjectId ?? "",
+    neonBaseBranchId: discovery.neonBaseBranchId ?? "",
+    neonBaseBranchName: discovery.neonBaseBranchName ?? "main",
+    neonDatabaseName: defaults.neonDatabaseName,
     generatorRoot: resolve(dirname(fileURLToPath(import.meta.url)), ".."),
   };
 }
 
+async function resolveRuntime(args: ParsedArgs): Promise<Runtime> {
+  if (args.runtime) {
+    return args.runtime;
+  }
+
+  if (args.yes) {
+    return "go";
+  }
+
+  const value = await select({
+    message: "Runtime",
+    initialValue: "go",
+    options: [
+      { value: "go", label: "Go", hint: "Default" },
+      { value: "bun", label: "Bun" },
+    ],
+  });
+
+  if (isCancel(value)) {
+    cancel("Aborted");
+    process.exit(1);
+  }
+
+  return value;
+}
+
+async function resolveFramework(args: ParsedArgs, runtime: Runtime): Promise<Framework> {
+  const allowed = FRAMEWORKS_BY_RUNTIME[runtime];
+  if (args.framework) {
+    if (allowed.includes(args.framework)) {
+      return args.framework;
+    }
+    throw new Error(`Framework ${args.framework} is not valid for runtime ${runtime}`);
+  }
+
+  if (args.yes) {
+    return allowed[0];
+  }
+
+  const value = await select({
+    message: "Framework",
+    initialValue: allowed[0],
+    options: allowed.map((framework, index) => ({
+      value: framework,
+      label: framework,
+      hint: index === 0 ? "Default" : undefined,
+    })),
+  });
+
+  if (isCancel(value)) {
+    cancel("Aborted");
+    process.exit(1);
+  }
+
+  return value;
+}
+
+async function resolveGcpSelection(
+  args: ParsedArgs,
+  defaults: ReturnType<typeof deriveDefaults>,
+  discovery: DiscoveryState
+) {
+  const options = buildGcpProjectOptions(defaults.serviceName, defaults.projectId, defaults.projectName, discovery.projects);
+
+  if (args.gcpProjectMode && args.gcpProject) {
+    return {
+      mode: args.gcpProjectMode,
+      projectId: args.gcpProject,
+      projectName: args.gcpProjectMode === "create_new" ? defaults.projectName : args.gcpProject,
+    };
+  }
+
+  if (args.gcpProjectMode === "create_new") {
+    return {
+      mode: "create_new" as const,
+      projectId: args.gcpProject ?? defaults.projectId,
+      projectName: defaults.projectName,
+    };
+  }
+
+  if (args.gcpProjectMode === "use_existing") {
+    const existing = discovery.projects.find((project) => project.projectId === args.gcpProject);
+    return {
+      mode: "use_existing" as const,
+      projectId: args.gcpProject ?? discovery.projects[0]?.projectId ?? defaults.projectId,
+      projectName: existing?.name ?? args.gcpProject ?? defaults.projectName,
+    };
+  }
+
+  if (args.yes) {
+    return {
+      mode: "create_new" as const,
+      projectId: defaults.projectId,
+      projectName: defaults.projectName,
+    };
+  }
+
+  const value = await select({
+    message: "GCP project",
+    initialValue: buildCreateProjectLabel(defaults.serviceName, defaults.projectId),
+    options: options.map((option) => ({
+      value: option.label,
+      label: option.label,
+      hint: option.mode === "create_new" ? "Default" : undefined,
+    })),
+  });
+
+  if (isCancel(value)) {
+    cancel("Aborted");
+    process.exit(1);
+  }
+
+  const selected = options.find((option) => option.label === value);
+  if (!selected) {
+    throw new Error(`Unknown GCP project selection: ${value}`);
+  }
+
+  return {
+    mode: selected.mode,
+    projectId: selected.projectId,
+    projectName: selected.projectName,
+  };
+}
+
+async function discoverCloudInputs(serviceName: string): Promise<DiscoveryState> {
+  const result: DiscoveryState = {
+    projects: [],
+    billingAccounts: [],
+    warnings: [],
+  };
+
+  try {
+    result.projects = await listAccessibleProjects();
+  } catch (error) {
+    result.warnings.push(`Skipping GCP project discovery: ${formatError(error)}`);
+  }
+
+  try {
+    result.billingAccounts = await listOpenBillingAccounts();
+  } catch (error) {
+    result.warnings.push(`Skipping billing account discovery: ${formatError(error)}`);
+  }
+
+  try {
+    const neonDefaults = await discoverNeonDefaults(serviceName);
+    result.neonProjectId = neonDefaults.projectId;
+    result.neonBaseBranchId = neonDefaults.baseBranchId;
+    result.neonBaseBranchName = neonDefaults.baseBranchName;
+  } catch (error) {
+    result.warnings.push(`Skipping Neon discovery: ${formatError(error)}`);
+  }
+
+  return result;
+}
+
+function chooseBillingAccount(input: string | undefined, accounts: BillingAccount[]) {
+  if (input) {
+    return input;
+  }
+
+  const preferred = accounts.find((account) => account.name === BILLING_ACCOUNT_DEFAULT);
+  if (preferred) {
+    return preferred.name;
+  }
+
+  return accounts[0]?.name ?? BILLING_ACCOUNT_DEFAULT;
+}
+
+function resolveAutoDeploy(value: boolean | undefined) {
+  if (value !== undefined) {
+    return value;
+  }
+  return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+
 async function promptText(
   message: string,
   initialValue: string,
@@ -270,17 +494,12 @@ async function promptText(
   return value.trim();
 }
 
-export function normalizeValidationResult(result: true | string): string | undefined {
-  return result === true ? undefined : result;
+function formatError(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
 }
 
-function slugify(value: string): string {
-  return value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 63);
+export function normalizeValidationResult(result: true | string): string | undefined {
+  return result === true ? undefined : result;
 }
 
 function printHelp() {
@@ -289,16 +508,17 @@ Usage:
   bun run index.ts [directory] [options]
 
 Options:
-  --module <path>               Go module path
-  --project-id <id>             GCP project ID
-  --region <region>             Cloud Run region
-  --github-repo <owner/repo>    GitHub repository
-  --vault-addr <url>            Vault address
-  --vault-secret-path <path>    Vault KV secret path
-  --vault-secret-key <key>      Vault KV secret key
-  --cloudflare-zone-id <id>     Cloudflare zone ID
-  --buf-module <module>         Buf module name
-  --yes, -y                     Accept defaults without prompts
-  --help, -h                    Show this message
+  --runtime <go|bun>              Runtime scaffold to generate
+  --framework <name>              Framework for the selected runtime
+  --project-mode <mode>           create_new or use_existing
+  --project-id <id>               GCP project id
+  --github-repo <owner/repo>      GitHub repository
+  --billing-account <name>        Billing account resource name
+  --quota-project <id>            Billing quota project for gcloud calls
+  --region <region>               Cloud Run region
+  --auto-deploy                   Run bootstrap and first deploy after scaffold
+  --no-auto-deploy                Scaffold only
+  --yes, -y                       Accept defaults without prompts
+  --help, -h                      Show this message
 `);
 }

package/src/gcp.test.ts

@@ -0,0 +1,71 @@
+import { expect, test } from "bun:test";
+import { attachBillingAccount, createProject, listAccessibleProjects, listOpenBillingAccounts, type GcpApi } from "./gcp";
+
+test("listAccessibleProjects filters deleted projects and sorts by name", async () => {
+  const api: GcpApi = {
+    async listProjects() {
+      return [
+        { projectId: "b", name: "bravo" },
+        { projectId: "a", name: "alpha" },
+        { projectId: "z", name: "zulu", lifecycleState: "DELETE_REQUESTED" },
+      ];
+    },
+    async listBillingAccounts() {
+      return [];
+    },
+    async createProject() {},
+    async attachBillingAccount() {},
+  };
+
+  await expect(listAccessibleProjects(api)).resolves.toEqual([
+    { projectId: "a", name: "alpha" },
+    { projectId: "b", name: "bravo" },
+  ]);
+});
+
+test("listOpenBillingAccounts keeps only open accounts", async () => {
+  const api: GcpApi = {
+    async listProjects() {
+      return [];
+    },
+    async listBillingAccounts() {
+      return [
+        { name: "billingAccounts/2", displayName: "B", open: true },
+        { name: "billingAccounts/1", displayName: "A", open: true },
+        { name: "billingAccounts/closed", displayName: "Z", open: false },
+      ];
+    },
+    async createProject() {},
+    async attachBillingAccount() {},
+  };
+
+  await expect(listOpenBillingAccounts(api)).resolves.toEqual([
+    { name: "billingAccounts/1", displayName: "A", open: true },
+    { name: "billingAccounts/2", displayName: "B", open: true },
+  ]);
+});
+
+test("createProject and attachBillingAccount call the expected endpoints", async () => {
+  const calls: string[] = [];
+  const api: GcpApi = {
+    async listProjects() {
+      return [];
+    },
+    async listBillingAccounts() {
+      return [];
+    },
+    async createProject(projectId, name) {
+      calls.push(`create:${projectId}:${name}`);
+    },
+    async attachBillingAccount(projectId, billingAccountName) {
+      calls.push(`billing:${projectId}:${billingAccountName}`);
+    },
+  };
+
+  await createProject("anmho-test", "test", api);
+  await attachBillingAccount("anmho-test", "billingAccounts/123", api);
+
+  expect(calls).toHaveLength(2);
+  expect(calls[0]).toBe("create:anmho-test:test");
+  expect(calls[1]).toBe("billing:anmho-test:billingAccounts/123");
+});