create-svc 0.1.9 → 0.1.11

package/src/cli.ts

@@ -5,6 +5,7 @@ import {
   intro,
   isCancel,
   log,
+  note,
   outro,
   select,
   spinner,
@@ -15,18 +16,21 @@ import { readdirSync } from "node:fs";
 import { basename, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { runPostScaffoldFlow } from "./post-scaffold";
+import { bootstrapGitHubRepository, buildGitBootstrapConfig, commitAndPushGeneratedArtifacts } from "./git-bootstrap";
 import { listOpenBillingAccounts, listAccessibleProjects, type BillingAccount, type GcpProject } from "./gcp";
-import { discoverNeonDefaults } from "./neon";
 import {
   BILLING_ACCOUNT_DEFAULT,
-  FRAMEWORKS_BY_RUNTIME,
   QUOTA_PROJECT_DEFAULT,
   deriveDefaults,
+  frameworksForTargetRuntime,
+  parseDeployTarget,
   slugify,
+  type DeployTarget,
   type Framework,
   type GcpProjectMode,
   type Runtime,
 } from "./naming";
+import { parseProfile, type Profile } from "./profiles";
 import {
   DirectoryConflictError,
   assertTargetDirectoryIsEmpty,
@@ -36,15 +40,20 @@ import {
 
 type ParsedArgs = {
   directory?: string;
+  target?: DeployTarget;
   runtime?: Runtime;
   framework?: Framework;
+  modulePath?: string;
   gcpProjectMode?: GcpProjectMode;
   gcpProject?: string;
-  githubRepo?: string;
   region?: string;
   billingAccount?: string;
   quotaProjectId?: string;
   autoDeploy?: boolean;
+  autoUpdate?: boolean;
+  noUpdateCheck?: boolean;
+  noGit?: boolean;
+  profile: Profile;
   yes: boolean;
   help: boolean;
 };
@@ -52,10 +61,6 @@ type ParsedArgs = {
 type DiscoveryState = {
   projects: GcpProject[];
   billingAccounts: BillingAccount[];
-  neonProjectId?: string;
-  neonBaseBranchId?: string;
-  neonBaseBranchName?: string;
-  neonError?: string;
   warnings: string[];
 };
 
@@ -69,7 +74,9 @@ export async function run(argv: string[]) {
       return;
     }
 
-    intro(`${pc.bold("create-svc")} ${pc.dim("Cloud Run scaffold")}`);
+    await maybeCheckForUpdate(args);
+
+    intro(`${pc.bold("create-service")} ${pc.dim("microservice bootstrap")}`);
 
     const config = await resolveConfig(args);
     const targetDir = resolve(process.cwd(), config.directory);
@@ -77,10 +84,12 @@ export async function run(argv: string[]) {
     note(
       [
         `${pc.bold("Output")}: ${targetDir}`,
+        `${pc.bold("Target")}: ${config.target}`,
         `${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)"}`,
+        `${pc.bold("API")}: https://${config.apiHostname}`,
+        `${pc.bold("Local DB")}: docker compose postgres`,
+        `${pc.bold("GitHub")}: ${config.git.enabled ? `anmho/${config.git.repository}` : "disabled"}`,
       ].join("\n"),
       "Scaffold"
     );
@@ -90,7 +99,18 @@ 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));
+    const gitSpinner = spinner();
+    gitSpinner.start("Preparing git repository");
+    const gitResult = await bootstrapGitHubRepository(targetDir, config.git);
+    if (gitResult.status === "created") {
+      gitSpinner.stop(`GitHub repository created: ${gitResult.url}`);
+    } else if (gitResult.status === "skipped-existing-worktree") {
+      gitSpinner.stop(`Existing git worktree detected: ${gitResult.root}`);
+    } else {
+      gitSpinner.stop("Git bootstrap disabled");
+    }
+
+    const shouldRunPostScaffoldFlow = config.autoDeploy;
     if (shouldRunPostScaffoldFlow) {
       const automationSpinner = spinner();
       automationSpinner.start("Running post-scaffold automation");
@@ -98,27 +118,44 @@ export async function run(argv: string[]) {
         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));
+        automationSpinner.stop("Post-scaffold automation failed");
+        throw error;
+      }
+
+      if (gitResult.status === "created") {
+        const publishSpinner = spinner();
+        publishSpinner.start("Publishing generated artifacts");
+        const result = commitAndPushGeneratedArtifacts(targetDir, "Record generated deployment artifacts");
+        publishSpinner.stop(result.committed ? "Generated artifacts committed and pushed" : "Generated artifacts already committed");
       }
     }
 
+    const isBun = config.runtime === "bun";
     outro(
       [
         `Next: ${pc.cyan(`cd ${config.directory}`)}`,
-        `Local dev: ${pc.cyan("bun dev")}`,
-        `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")
+        `Local DB: ${pc.cyan("started by local dev command")}`,
+        `Migrate: ${pc.cyan(isBun ? "bun run migrate" : "make migrate")}`,
+        `Local dev: ${pc.cyan(isBun ? "bun run dev" : "make dev")}`,
+        `Create: ${pc.cyan(isBun ? "bun run service -- create" : "make create")}`,
+        `Deploy: ${pc.cyan(isBun ? "bun run service -- deploy" : "make deploy")}`,
+        config.git.enabled ? `Repository: ${pc.cyan(`https://github.com/anmho/${config.git.repository}`)}` : undefined,
+        `Personal env: ${pc.cyan(
+          isBun
+            ? `bun run deploy -- --environment personal --name ${config.serviceName}`
+            : `make deploy ARGS="--environment personal --name ${config.serviceName}"`
+        )}`,
+        `Production API: ${pc.cyan(`https://${config.apiHostname}`)}`,
+      ].filter(Boolean).join("\n")
     );
   } catch (error) {
     handleCliError(error);
   }
 }
 
-function parseArgs(argv: string[]): ParsedArgs {
+export function parseArgs(argv: string[]): ParsedArgs {
   const parsed: ParsedArgs = {
+    profile: "microservice",
     yes: false,
     help: false,
   };
@@ -153,6 +190,21 @@ function parseArgs(argv: string[]): ParsedArgs {
       continue;
     }
 
+    if (token === "--auto-update") {
+      parsed.autoUpdate = true;
+      continue;
+    }
+
+    if (token === "--no-update-check") {
+      parsed.noUpdateCheck = true;
+      continue;
+    }
+
+    if (token === "--no-git") {
+      parsed.noGit = true;
+      continue;
+    }
+
     if (token === "--runtime") {
       parsed.runtime = readValue() as Runtime;
       continue;
@@ -163,6 +215,16 @@ function parseArgs(argv: string[]): ParsedArgs {
       continue;
     }
 
+    if (token === "--target") {
+      parsed.target = parseDeployTarget(readValue());
+      continue;
+    }
+
+    if (token.startsWith("--target=")) {
+      parsed.target = parseDeployTarget(token.slice("--target=".length));
+      continue;
+    }
+
     if (token === "--framework") {
       parsed.framework = readValue() as Framework;
       continue;
@@ -173,6 +235,26 @@ function parseArgs(argv: string[]): ParsedArgs {
       continue;
     }
 
+    if (token === "--profile") {
+      parsed.profile = parseProfile(readValue());
+      continue;
+    }
+
+    if (token.startsWith("--profile=")) {
+      parsed.profile = parseProfile(token.slice("--profile=".length));
+      continue;
+    }
+
+    if (token === "--module-path") {
+      parsed.modulePath = readValue();
+      continue;
+    }
+
+    if (token.startsWith("--module-path=")) {
+      parsed.modulePath = token.slice("--module-path=".length);
+      continue;
+    }
+
     if (token === "--project-mode") {
       parsed.gcpProjectMode = readValue() as GcpProjectMode;
       continue;
@@ -198,16 +280,6 @@ function parseArgs(argv: string[]): ParsedArgs {
       continue;
     }
 
-    if (token === "--github-repo") {
-      parsed.githubRepo = readValue();
-      continue;
-    }
-
-    if (token.startsWith("--github-repo=")) {
-      parsed.githubRepo = token.slice("--github-repo=".length);
-      continue;
-    }
-
     if (token === "--region") {
       parsed.region = readValue();
       continue;
@@ -254,6 +326,69 @@ function parseArgs(argv: string[]): ParsedArgs {
   return parsed;
 }
 
+const CURRENT_VERSION = "0.1.9";
+const PACKAGE_NAME = "create-svc";
+
+async function maybeCheckForUpdate(args: ParsedArgs) {
+  if (args.noUpdateCheck || shouldSkipUpdateCheck()) {
+    return;
+  }
+
+  const latest = await resolveLatestVersion().catch(() => "");
+  if (!latest || !isVersionGreater(latest, CURRENT_VERSION)) {
+    return;
+  }
+
+  const command = `bunx ${PACKAGE_NAME}@latest ${Bun.argv.slice(2).filter((arg) => arg !== "--auto-update").join(" ")}`.trim();
+  if (!args.autoUpdate) {
+    log.info(`A newer ${PACKAGE_NAME} is available: ${CURRENT_VERSION} -> ${latest}. Run ${command}`);
+    return;
+  }
+
+  const result = Bun.spawnSync(["bunx", `${PACKAGE_NAME}@latest`, ...Bun.argv.slice(2).filter((arg) => arg !== "--auto-update")], {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    env: {
+      ...process.env,
+      CREATE_SERVICE_NO_UPDATE_CHECK: "1",
+    },
+  });
+  process.exit(result.exitCode);
+}
+
+function shouldSkipUpdateCheck() {
+  return Boolean(
+    process.env.CI ||
+      process.env.CODEX_CI ||
+      process.env.CREATE_SERVICE_NO_UPDATE_CHECK ||
+      process.env.BUN_TEST ||
+      process.env.npm_lifecycle_event
+  );
+}
+
+async function resolveLatestVersion() {
+  const response = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+    signal: AbortSignal.timeout(1_500),
+  });
+  if (!response.ok) {
+    return "";
+  }
+  const payload = (await response.json()) as { version?: string };
+  return payload.version?.trim() ?? "";
+}
+
+function isVersionGreater(left: string, right: string) {
+  const parse = (value: string) => value.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const [leftMajor = 0, leftMinor = 0, leftPatch = 0] = parse(left);
+  const [rightMajor = 0, rightMinor = 0, rightPatch = 0] = parse(right);
+  return (
+    leftMajor > rightMajor ||
+    (leftMajor === rightMajor && leftMinor > rightMinor) ||
+    (leftMajor === rightMajor && leftMinor === rightMinor && leftPatch > rightPatch)
+  );
+}
+
 export async function resolveConfig(args: ParsedArgs): Promise<ScaffoldConfig> {
   const inferredName = slugify(basename(args.directory ?? "my-service"));
   const serviceName = args.yes
@@ -265,15 +400,17 @@ export async function resolveConfig(args: ParsedArgs): Promise<ScaffoldConfig> {
 
   const discoveryPromise = discoverCloudInputs();
   const defaults = deriveDefaults(serviceName);
-  const runtime = await resolveRuntime(args);
-  const framework = await resolveFramework(args, runtime);
-  const discovery = await discoveryPromise;
-  assertDiscoveryReady(discovery);
+  const target = await resolveTarget(args);
+  const runtime = await resolveRuntime(args, target);
+  const framework = await resolveFramework(args, target, runtime);
+  validateTargetRuntimeFramework(target, runtime, framework);
+  const modulePath = await resolveModulePath(args, runtime, defaults.modulePath);
+  const discovery = await waitForDiscovery(discoveryPromise);
   const gcpSelection = await resolveGcpSelection(args, defaults, discovery);
-  const githubRepo = args.githubRepo ?? defaults.githubRepo;
   const region = args.region ?? DEFAULT_REGION;
   const billingAccount = chooseBillingAccount(args.billingAccount, discovery.billingAccounts);
   const autoDeploy = resolveAutoDeploy(args.autoDeploy);
+  const git = buildGitBootstrapConfig(serviceName, args.noGit);
 
   if (!args.yes) {
     const okay = await confirm({
@@ -293,42 +430,87 @@ export async function resolveConfig(args: ParsedArgs): Promise<ScaffoldConfig> {
   return {
     directory,
     serviceName,
+    modulePath,
+    target,
     runtime,
     framework,
+    profile: args.profile,
     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",
+    git,
     neonDatabaseName: defaults.neonDatabaseName,
+    apiHostname: defaults.apiHostname,
     generatorRoot: resolve(dirname(fileURLToPath(import.meta.url)), ".."),
   };
 }
 
-async function resolveRuntime(args: ParsedArgs): Promise<Runtime> {
+async function waitForDiscovery(discoveryPromise: Promise<DiscoveryState>) {
+  const indicator = spinner();
+  indicator.start("Discovering GCP defaults");
+  try {
+    const discovery = await discoveryPromise;
+    indicator.stop("GCP defaults discovered");
+    return discovery;
+  } catch (error) {
+    indicator.stop("GCP defaults discovery failed");
+    throw error;
+  }
+}
+
+async function resolveTarget(args: ParsedArgs): Promise<DeployTarget> {
+  if (args.target) {
+    return args.target;
+  }
+
+  if (args.yes) {
+    return "cloudrun";
+  }
+
+  const value = await select({
+    message: "Deploy target",
+    initialValue: "cloudrun",
+    options: [
+      { value: "cloudrun", label: "Cloud Run", hint: "Default" },
+      { value: "workers", label: "Cloudflare Workers" },
+    ],
+  });
+
+  if (isCancel(value)) {
+    cancel("Aborted");
+    process.exit(1);
+  }
+
+  return value as DeployTarget;
+}
+
+async function resolveRuntime(args: ParsedArgs, target: DeployTarget): Promise<Runtime> {
   if (args.runtime) {
     return args.runtime;
   }
 
+  if (target === "workers") {
+    return "bun";
+  }
+
   if (args.yes) {
     return "go";
   }
 
   const value = await select({
     message: "Runtime",
-    initialValue: "go",
-    options: [
-      { value: "go", label: "Go", hint: "Default" },
-      { value: "bun", label: "Bun" },
-    ],
+    initialValue: target === "cloudrun" ? "go" : "bun",
+    options:
+      target === "cloudrun"
+        ? [
+            { value: "go", label: "Go", hint: "Default" },
+            { value: "bun", label: "Bun" },
+          ]
+        : [{ value: "bun", label: "Bun/TypeScript", hint: "Workers runtime" }],
   });
 
   if (isCancel(value)) {
@@ -336,20 +518,20 @@ async function resolveRuntime(args: ParsedArgs): Promise<Runtime> {
     process.exit(1);
   }
 
-  return value;
+  return value as Runtime;
 }
 
-async function resolveFramework(args: ParsedArgs, runtime: Runtime): Promise<Framework> {
-  const allowed = FRAMEWORKS_BY_RUNTIME[runtime];
+async function resolveFramework(args: ParsedArgs, target: DeployTarget, runtime: Runtime): Promise<Framework> {
+  const allowed = frameworksForTargetRuntime(target, runtime);
   if (args.framework) {
-    if (allowed.includes(args.framework)) {
+    if (allowed.some((framework) => framework === args.framework)) {
       return args.framework;
     }
-    throw new Error(`Framework ${args.framework} is not valid for runtime ${runtime}`);
+    throw new Error(`Framework ${args.framework} is not valid for target ${target} and runtime ${runtime}`);
   }
 
   if (args.yes) {
-    return allowed[0];
+    return target === "cloudrun" && runtime === "go" ? "connectrpc" : allowed[0]!;
   }
 
   const value = await select({
@@ -367,7 +549,28 @@ async function resolveFramework(args: ParsedArgs, runtime: Runtime): Promise<Fra
     process.exit(1);
   }
 
-  return value;
+  return value as Framework;
+}
+
+async function resolveModulePath(args: ParsedArgs, runtime: Runtime, initialValue: string) {
+  if (runtime !== "go") {
+    return args.modulePath ?? initialValue;
+  }
+
+  if (args.modulePath) {
+    return args.modulePath.trim();
+  }
+
+  if (args.yes) {
+    return initialValue;
+  }
+
+  return promptText("Go module path", initialValue, (value) => {
+    if (!value.trim()) {
+      return "Go module path is required";
+    }
+    return true;
+  });
 }
 
 async function resolveGcpSelection(
@@ -483,24 +686,11 @@ async function discoverCloudInputs(): Promise<DiscoveryState> {
     result.warnings.push(`Skipping billing account discovery: ${formatError(error)}`);
   }
 
-  try {
-    const neonDefaults = await discoverNeonDefaults();
-    result.neonProjectId = neonDefaults.projectId;
-    result.neonBaseBranchId = neonDefaults.baseBranchId;
-    result.neonBaseBranchName = neonDefaults.baseBranchName;
-  } catch (error) {
-    result.neonError = formatError(error);
-  }
-
   return result;
 }
 
 export function assertDiscoveryReady(discovery: DiscoveryState) {
-  if (!discovery.neonError) {
-    return;
-  }
-
-  throw new Error(formatNeonDiscoveryRequirement(discovery.neonError));
+  return discovery;
 }
 
 function chooseBillingAccount(input: string | undefined, accounts: BillingAccount[]) {
@@ -520,7 +710,7 @@ function resolveAutoDeploy(value: boolean | undefined) {
   if (value !== undefined) {
     return value;
   }
-  return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+  return false;
 }
 
 async function promptText(
@@ -531,7 +721,7 @@ async function promptText(
   const value = await text({
     message,
     initialValue,
-    validate: (input) => normalizeValidationResult(validate(input.trim())),
+    validate: (input) => normalizeValidationResult(validate((input ?? "").trim())),
   });
 
   if (isCancel(value)) {
@@ -546,18 +736,6 @@ function formatError(error: unknown) {
   return error instanceof Error ? error.message : String(error);
 }
 
-function formatNeonDiscoveryRequirement(reason: string) {
-  if (reason.includes("Vault secret resolution requires")) {
-    return [
-      "Neon discovery is required before scaffolding.",
-      "Set NEON_API_KEY, or use Vault by providing VAULT_ADDR and either VAULT_TOKEN, VAULT_TOKEN_FILE, or ~/.vault-token.",
-      "Optional overrides: VAULT_SECRET_MOUNT, VAULT_NEON_API_KEY_PATH, VAULT_NEON_API_KEY_FIELD.",
-    ].join(" ");
-  }
-
-  return `Neon discovery is required before scaffolding: ${reason}`;
-}
-
 function handleCliError(error: unknown) {
   if (error instanceof DirectoryConflictError) {
     log.error(`Target directory already exists and is not empty: ${error.targetDir}`);
@@ -612,6 +790,17 @@ export function normalizeValidationResult(result: true | string): string | undef
   return result === true ? undefined : result;
 }
 
+export function validateProfileRuntimeFramework(profile: Profile, runtime: Runtime, framework: Framework) {
+  validateTargetRuntimeFramework("cloudrun", runtime, framework);
+}
+
+export function validateTargetRuntimeFramework(target: DeployTarget, runtime: Runtime, framework: Framework) {
+  const allowed = frameworksForTargetRuntime(target, runtime);
+  if (!allowed.some((candidate) => candidate === framework)) {
+    throw new Error(`Framework ${framework} is not valid for target ${target} and runtime ${runtime}`);
+  }
+}
+
 export function validateServiceNameInput(rawValue: string, directoryOverride?: string) {
   const serviceName = slugify(rawValue);
   if (!serviceName) {
@@ -638,20 +827,29 @@ export function validateServiceNameInput(rawValue: string, directoryOverride?: s
 function printHelp() {
   log.message(`
 Usage:
-  bun run index.ts [directory] [options]
+  create-service [service_id] [options]
 
 Options:
+  --target <cloudrun|workers>     Deploy target for the generated service
+  --profile <microservice>        Compatibility no-op; app workspaces moved out
   --runtime <go|bun>              Runtime scaffold to generate
   --framework <name>              Framework for the selected runtime
+  --module-path <path>            Go module path for generated Go scaffolds
   --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
+  --auto-deploy                   Run service create and service deploy after scaffold
   --no-auto-deploy                Scaffold only
+  --no-git                        Skip git init, initial commit, GitHub repo creation, and push
+  --auto-update                   Re-run through create-svc@latest when a newer version exists
+  --no-update-check               Skip the best-effort npm update check
   --yes, -y                       Accept defaults without prompts
   --help, -h                      Show this message
 `);
 }
+
+function matchesProject(project: GcpProject, query: string) {
+  return project.projectId === query || project.name === query;
+}

package/src/git-bootstrap.test.ts

@@ -0,0 +1,40 @@
+import { expect, test } from "bun:test";
+import { mkdir, mkdtemp, realpath } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { buildGitBootstrapConfig, findExistingGitWorktree } from "./git-bootstrap";
+
+test("buildGitBootstrapConfig defaults to anmho private repo creation", () => {
+  expect(buildGitBootstrapConfig("launch-api", undefined)).toEqual({
+    enabled: true,
+    owner: "anmho",
+    repository: "launch-api",
+  });
+});
+
+test("buildGitBootstrapConfig honors --no-git", () => {
+  expect(buildGitBootstrapConfig("launch-api", true)).toEqual({
+    enabled: false,
+    owner: "anmho",
+    repository: "launch-api",
+  });
+});
+
+test("findExistingGitWorktree detects parent repositories", async () => {
+  const root = await mkdtemp(join(tmpdir(), "create-svc-git-"));
+  run(["git", "init", "-b", "main"], root);
+  await mkdir(join(root, "apps", "launch-api"), { recursive: true });
+
+  expect(findExistingGitWorktree(join(root, "apps", "launch-api"))).toBe(await realpath(root));
+});
+
+function run(command: string[], cwd: string) {
+  const result = Bun.spawnSync(command, {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr.toString());
+  }
+}