create-svc 0.1.37 → 0.1.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-svc",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "description": "Local microservice bootstrap CLI for Cloud Run and Workers services with Neon-backed data.",
   "module": "index.ts",
   "type": "module",

package/src/cli.ts

@@ -11,7 +11,13 @@ import {
   markGitHubRepositoryDeleteOnDestroy,
   type GitBootstrapResult,
 } from "./git-bootstrap";
-import { listOpenBillingAccounts, listAccessibleProjects, type BillingAccount, type GcpProject } from "./gcp";
+import {
+  assertExistingProjectReadyForAutoDeploy,
+  listOpenBillingAccounts,
+  listAccessibleProjects,
+  type BillingAccount,
+  type GcpProject,
+} from "./gcp";
 import {
   BILLING_ACCOUNT_DEFAULT,
   QUOTA_PROJECT_DEFAULT,
@@ -91,6 +97,7 @@ export async function run(argv: string[]) {
 
     const config = await resolveConfig(args);
     const targetDir = resolve(process.cwd(), config.directory);
+    await assertPreScaffoldReady(config);
 
     note(
       [
@@ -959,6 +966,14 @@ export function assertDiscoveryReady(discovery: DiscoveryState) {
   return discovery;
 }
 
+async function assertPreScaffoldReady(config: ScaffoldConfig) {
+  if (config.target !== "cloudrun" || !config.autoDeploy || config.gcpProjectMode !== "use_existing") {
+    return;
+  }
+
+  await assertExistingProjectReadyForAutoDeploy(config.gcpProject);
+}
+
 function chooseBillingAccount(input: string | undefined, accounts: BillingAccount[]) {
   if (input) {
     return input;

package/src/gcp.test.ts

@@ -1,5 +1,12 @@
 import { expect, test } from "bun:test";
-import { attachBillingAccount, createProject, listAccessibleProjects, listOpenBillingAccounts, type GcpApi } from "./gcp";
+import {
+  assertExistingProjectReadyForAutoDeploy,
+  attachBillingAccount,
+  createProject,
+  listAccessibleProjects,
+  listOpenBillingAccounts,
+  type GcpApi,
+} from "./gcp";
 
 test("listAccessibleProjects filters deleted projects and sorts by name", async () => {
   const api: GcpApi = {
@@ -105,3 +112,70 @@ test("createProject and attachBillingAccount call the expected endpoints", async
   expect(calls[0]).toBe("create:anmho-test:test");
   expect(calls[1]).toBe("billing:anmho-test:billingAccounts/123");
 });
+
+test("assertExistingProjectReadyForAutoDeploy passes when project exists with billing", async () => {
+  const api: GcpApi = {
+    async listProjects() {
+      return [];
+    },
+    async listBillingAccounts() {
+      return [];
+    },
+    async describeProject(projectId) {
+      return { projectId, name: "services" };
+    },
+    async describeBillingProject() {
+      return { billingEnabled: true, billingAccountName: "billingAccounts/123" };
+    },
+    async createProject() {},
+    async attachBillingAccount() {},
+  };
+
+  await expect(assertExistingProjectReadyForAutoDeploy("anmho-services", api)).resolves.toBeUndefined();
+});
+
+test("assertExistingProjectReadyForAutoDeploy rejects missing projects", async () => {
+  const api: GcpApi = {
+    async listProjects() {
+      return [];
+    },
+    async listBillingAccounts() {
+      return [];
+    },
+    async describeProject() {
+      throw new Error("not found");
+    },
+    async describeBillingProject() {
+      return { billingEnabled: true };
+    },
+    async createProject() {},
+    async attachBillingAccount() {},
+  };
+
+  await expect(assertExistingProjectReadyForAutoDeploy("anmho-services", api)).rejects.toThrow(
+    "GCP project anmho-services does not exist or is not accessible"
+  );
+});
+
+test("assertExistingProjectReadyForAutoDeploy rejects projects without billing", async () => {
+  const api: GcpApi = {
+    async listProjects() {
+      return [];
+    },
+    async listBillingAccounts() {
+      return [];
+    },
+    async describeProject(projectId) {
+      return { projectId, name: "services" };
+    },
+    async describeBillingProject() {
+      return { billingEnabled: false };
+    },
+    async createProject() {},
+    async attachBillingAccount() {},
+  };
+
+  await expect(assertExistingProjectReadyForAutoDeploy("anmho-services", api)).rejects.toThrow(
+    "GCP project anmho-services exists but billing is not enabled"
+  );
+});

package/src/gcp.ts

@@ -10,9 +10,16 @@ export type BillingAccount = {
   open: boolean;
 };
 
+export type BillingProject = {
+  billingEnabled?: boolean;
+  billingAccountName?: string;
+};
+
 export type GcpApi = {
   listProjects(): Promise<GcpProject[]>;
   listBillingAccounts(): Promise<BillingAccount[]>;
+  describeProject?(projectId: string): Promise<GcpProject>;
+  describeBillingProject?(projectId: string): Promise<BillingProject>;
   createProject(projectId: string, name: string): Promise<void>;
   attachBillingAccount(projectId: string, billingAccountName: string): Promise<void>;
 };
@@ -33,6 +40,20 @@ export function createGcpApi(): GcpApi {
       );
     },
 
+    async describeProject(projectId: string) {
+      return parseJson<GcpProject>(
+        runGcloud(["projects", "describe", projectId, "--format=json(projectId,name,lifecycleState)"]).stdout,
+        "GCP project"
+      );
+    },
+
+    async describeBillingProject(projectId: string) {
+      return parseJson<BillingProject>(
+        runGcloud(["beta", "billing", "projects", "describe", projectId, "--format=json(billingEnabled,billingAccountName)"]).stdout,
+        "GCP project billing"
+      );
+    },
+
     async createProject(projectId: string, name: string) {
       runGcloud(["projects", "create", projectId, "--name", name]);
     },
@@ -64,6 +85,46 @@ export async function attachBillingAccount(projectId: string, billingAccountName
   await api.attachBillingAccount(projectId, billingAccountName);
 }
 
+export async function assertExistingProjectReadyForAutoDeploy(projectId: string, api = createGcpApi()) {
+  try {
+    await api.describeProject?.(projectId);
+  } catch (error) {
+    throw new Error(
+      [
+        `GCP project ${projectId} does not exist or is not accessible.`,
+        "Create and enable billing on that project before one-shot create, pass --project-id <billed-project>, or pass --no-auto-deploy.",
+        formatErrorDetail(error),
+      ]
+        .filter(Boolean)
+        .join("\n")
+    );
+  }
+
+  let billing: BillingProject;
+  try {
+    billing = (await api.describeBillingProject?.(projectId)) ?? {};
+  } catch (error) {
+    throw new Error(
+      [
+        `Unable to verify billing for GCP project ${projectId}.`,
+        "Fix billing access before one-shot create, pass --project-id <billed-project>, or pass --no-auto-deploy.",
+        formatErrorDetail(error),
+      ]
+        .filter(Boolean)
+        .join("\n")
+    );
+  }
+
+  if (!billing.billingEnabled) {
+    throw new Error(
+      [
+        `GCP project ${projectId} exists but billing is not enabled.`,
+        "Link billing before one-shot create, pass --project-id <billed-project>, or pass --no-auto-deploy.",
+      ].join("\n")
+    );
+  }
+}
+
 function runGcloud(args: string[]) {
   const result = Bun.spawnSync(["gcloud", ...args], {
     stdout: "pipe",
@@ -87,6 +148,11 @@ function accountSortName(account: BillingAccount) {
   return account.displayName || account.name;
 }
 
+function formatErrorDetail(error: unknown) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message ? `Details: ${message}` : undefined;
+}
+
 function parseJson<T>(value: string, label: string): T {
   try {
     return JSON.parse(value) as T;

package/src/service-runtime/cloudrun/cleanup.ts

@@ -75,8 +75,9 @@ export async function cleanup(args = Bun.argv.slice(2)) {
   }
 
   await requireDestroyConfirmation(options.force);
+  const deleteGitHubRepository = await confirmGitHubRepositoryDeletion(plan.githubRepository, options.force);
 
-  await deletePlannedResources(plan);
+  await deletePlannedResources(plan, { deleteGitHubRepository });
 
   if (options.destroyProject) {
     await runStep(`Deleting GCP project ${config.project.id}`, () => deleteProject());
@@ -87,7 +88,7 @@ export async function cleanup(args = Bun.argv.slice(2)) {
   return `Destroy finished for ${config.serviceName}`;
 }
 
-async function deletePlannedResources(plan: DestroyPlan) {
+async function deletePlannedResources(plan: DestroyPlan, options: { deleteGitHubRepository: boolean }) {
   const tasks: ParallelTask[] = [
     {
       label: "Stopping local dev resources",
@@ -135,7 +136,7 @@ async function deletePlannedResources(plan: DestroyPlan) {
     },
   ];
 
-  if (plan.githubRepository) {
+  if (plan.githubRepository && options.deleteGitHubRepository) {
     tasks.push({
       label: `Deleting GitHub repository ${plan.githubRepository}`,
       task: () => deleteGitHubRepository(plan.githubRepository!),
@@ -246,7 +247,10 @@ function planGitHubRepository(plan: DestroyPlan) {
   }
 
   plan.githubRepository = repository;
-  plan.resources.push({ label: `GitHub repository ${repository}`, detail: "private generated repo" });
+  plan.skipped.push({
+    label: `GitHub repository ${repository}`,
+    detail: "owned by this service CLI run; deletion is optional and defaults to no",
+  });
 }
 
 function deleteGitHubRepository(repository: string) {
@@ -400,6 +404,41 @@ async function requireDestroyConfirmation(force: boolean) {
   }
 }
 
+async function confirmGitHubRepositoryDeletion(repository: string | undefined, force: boolean) {
+  if (!repository) {
+    return false;
+  }
+
+  if (force) {
+    log.step(`Keeping GitHub repository ${repository}; delete manually with: ${manualGitHubDeleteCommand(repository)}`);
+    return false;
+  }
+
+  if (!process.stdin.isTTY) {
+    return false;
+  }
+
+  const deleteAnswer = await confirm({
+    message: `Delete GitHub repository ${repository}?`,
+    initialValue: false,
+  });
+  if (isCancel(deleteAnswer) || !deleteAnswer) {
+    log.step(`Keeping GitHub repository ${repository}; delete manually with: ${manualGitHubDeleteCommand(repository)}`);
+    return false;
+  }
+
+  const confirmAnswer = await confirm({
+    message: `Confirm deleting GitHub repository ${repository}? This cannot be undone.`,
+    initialValue: false,
+  });
+  if (isCancel(confirmAnswer) || !confirmAnswer) {
+    log.step(`Keeping GitHub repository ${repository}; delete manually with: ${manualGitHubDeleteCommand(repository)}`);
+    return false;
+  }
+
+  return true;
+}
+
 if (import.meta.main) {
   await runMain("Destroy", () => cleanup(Bun.argv.slice(2)));
 }

package/src/service-runtime/workers/cli.ts

@@ -97,7 +97,9 @@ export async function main(argv = Bun.argv.slice(2)) {
       await requireDestroyConfirmation(rest.includes("--force"));
       const wranglerArgs = rest.filter((arg) => arg !== "--force");
       await stopLocalDev({ dockerCompose: false });
-      deleteGitHubRepositoryIfOwned();
+      if (await confirmGitHubRepositoryDeletion(rest.includes("--force"))) {
+        deleteGitHubRepositoryIfOwned();
+      }
       await deleteHyperdrive();
       run("wrangler", ["delete", "--name", config.serviceName, "--force", ...wranglerArgs]);
       await deleteNeonDatabase();
@@ -152,6 +154,47 @@ function deleteGitHubRepositoryIfOwned() {
   run("gh", ["repo", "delete", repository, "--yes"]);
 }
 
+async function confirmGitHubRepositoryDeletion(force: boolean) {
+  const repository = `${config.git.owner}/${config.git.repository}`;
+  if (!config.git.deleteOnDestroy) {
+    log.step(
+      `Skipping GitHub repository ${repository}: ${
+        config.git.enabled ? `not created by this service CLI run; manual cleanup: ${manualGitHubDeleteCommand(repository)}` : "git disabled"
+      }`
+    );
+    return false;
+  }
+
+  if (force) {
+    log.step(`Keeping GitHub repository ${repository}; delete manually with: ${manualGitHubDeleteCommand(repository)}`);
+    return false;
+  }
+
+  if (!process.stdin.isTTY) {
+    return false;
+  }
+
+  const deleteAnswer = await confirm({
+    message: `Delete GitHub repository ${repository}?`,
+    initialValue: false,
+  });
+  if (isCancel(deleteAnswer) || !deleteAnswer) {
+    log.step(`Keeping GitHub repository ${repository}; delete manually with: ${manualGitHubDeleteCommand(repository)}`);
+    return false;
+  }
+
+  const confirmAnswer = await confirm({
+    message: `Confirm deleting GitHub repository ${repository}? This cannot be undone.`,
+    initialValue: false,
+  });
+  if (isCancel(confirmAnswer) || !confirmAnswer) {
+    log.step(`Keeping GitHub repository ${repository}; delete manually with: ${manualGitHubDeleteCommand(repository)}`);
+    return false;
+  }
+
+  return true;
+}
+
 function run(command: string, args: string[], options: { allowFailure?: boolean; capture?: boolean } = {}) {
   if (!Bun.which(command)) {
     throw new Error(`missing required command: ${command}`);

package/src/service.test.ts

@@ -2,13 +2,12 @@ import { expect, test } from "bun:test";
 import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { findGeneratedServiceRoot, generatedDependenciesInstalled, normalizeScaffoldArgs } from "./service";
+import { findGeneratedServiceRoot, formatOutsideServiceCommandError, generatedDependenciesInstalled, normalizeScaffoldArgs } from "./service";
 
-test("normalizeScaffoldArgs treats service create as the scaffold command outside a service repo", () => {
+test("normalizeScaffoldArgs treats explicit scaffold commands as generator commands", () => {
   expect(normalizeScaffoldArgs(["create", "launch-api", "--yes"])).toEqual(["launch-api", "--yes"]);
   expect(normalizeScaffoldArgs(["new", "launch-api"])).toEqual(["launch-api"]);
   expect(normalizeScaffoldArgs(["init", "launch-api"])).toEqual(["launch-api"]);
-  expect(normalizeScaffoldArgs(["launch-api", "--yes"])).toEqual(["launch-api", "--yes"]);
 });
 
 test("normalizeScaffoldArgs maps service help to generator help outside a service repo", () => {
@@ -16,6 +15,17 @@ test("normalizeScaffoldArgs maps service help to generator help outside a servic
   expect(normalizeScaffoldArgs(["help", "--verbose"])).toEqual(["--help", "--verbose"]);
 });
 
+test("formatOutsideServiceCommandError rejects repo-local commands outside generated services", () => {
+  expect(formatOutsideServiceCommandError("destroy")).toContain("service destroy must be run inside a generated service repo");
+  expect(formatOutsideServiceCommandError("deploy")).toContain("No service.jsonc was found");
+});
+
+test("formatOutsideServiceCommandError does not treat positional names as scaffold commands", () => {
+  const message = formatOutsideServiceCommandError("launch-api");
+  expect(message).toContain("Unknown command: launch-api");
+  expect(message).toContain("service create <service_id>");
+});
+
 test("findGeneratedServiceRoot detects generated service context from nested directories", async () => {
   const root = await mkdtemp(join(tmpdir(), "create-svc-service-root-"));
   const serviceRoot = join(root, "generated-api");

package/src/service.ts

@@ -1,9 +1,22 @@
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { run as runScaffoldCli } from "./cli";
+import { formatScaffoldHelp, run as runScaffoldCli } from "./cli";
 import { parseJsonc } from "./jsonc";
 
 const SCAFFOLD_COMMANDS = new Set(["create", "new", "init"]);
+const GENERATED_SERVICE_COMMANDS = new Set([
+  "auth",
+  "create",
+  "dashboards",
+  "deploy",
+  "destroy",
+  "dev",
+  "dns",
+  "doctor",
+  "migrate",
+  "sdk",
+  "seed",
+]);
 
 export async function runServiceCommand(argv: string[], cwd = process.cwd()) {
   const serviceRoot = findGeneratedServiceRoot(cwd);
@@ -12,7 +25,19 @@ export async function runServiceCommand(argv: string[], cwd = process.cwd()) {
     return;
   }
 
-  await runScaffoldCli(normalizeScaffoldArgs(argv));
+  const [command] = argv;
+  if (!command || command === "--help" || command === "-h" || command === "help") {
+    console.log(formatScaffoldHelp());
+    return;
+  }
+
+  if (SCAFFOLD_COMMANDS.has(command)) {
+    await runScaffoldCli(normalizeScaffoldArgs(argv));
+    return;
+  }
+
+  console.error(formatOutsideServiceCommandError(command));
+  process.exit(1);
 }
 
 export function normalizeScaffoldArgs(argv: string[]) {
@@ -26,6 +51,20 @@ export function normalizeScaffoldArgs(argv: string[]) {
   return argv;
 }
 
+export function formatOutsideServiceCommandError(command: string) {
+  if (GENERATED_SERVICE_COMMANDS.has(command)) {
+    return [
+      `service ${command} must be run inside a generated service repo.`,
+      "",
+      "No service.jsonc was found in this directory or its parents.",
+      "To create a new service, run:",
+      "  service create <service_id>",
+    ].join("\n");
+  }
+
+  return [`Unknown command: ${command}`, "", formatScaffoldHelp()].join("\n");
+}
+
 export function findGeneratedServiceRoot(start: string): string | undefined {
   let current = start;
   while (true) {