create-svc 0.1.8 → 0.1.10

package/README.md

@@ -1,32 +1,161 @@
 # create-svc
 
-`create-svc` is a Bun-authored scaffold CLI for generating a Go Cloud Run service with:
+`create-svc` is a local backend bootstrap CLI for generating standalone Cloud Run API services with:
 
-- Chi HTTP routes
-- ConnectRPC handlers
-- a real Cloud Run service manifest
-- Bun-based deployment helpers
-- Vault-backed Cloudflare DNS CRUD as the default example
+- a single `microservice` generation path
+- a Bun-first backend path built around `hono` and ConnectRPC
+- standalone package output that does not assume repo bootstrap
+- compatibility with future monorepo use in layouts like `apps/<service>`
+- a real `service.yaml` manifest
+- shared Cloud Run bootstrap, deploy, and cleanup automation
+- local Docker Compose Postgres for first-run development
+- Neon-backed remote main, preview, and personal environments
+- GCS-backed image attachments
+- typed HTTP webhook ingress
+- a production API origin at `https://api.<appname>.anmho.com`
+
+Local provisioning intentionally prefers known-good CLIs, especially `gcloud`, over SDK-heavy orchestration for Google Cloud operations.
+Terraform, control planes, and platform consoles are optional advanced paths, not default prerequisites.
+
+npm: <https://www.npmjs.com/package/create-svc>
 
 ## Usage
 
+```bash
+bun create svc my-service
+```
+
+or:
+
+```bash
+bunx create-svc my-service
+```
+
+For the strict one-command production path:
+
+```bash
+bun create svc my-service --profile microservice --bootstrap --yes
+```
+
+`--profile microservice` is accepted as a compatibility no-op. Full app workspaces live in the private GitHub template repos `anmho/create-app-consumer` and `anmho/create-app-saas`.
+
+## Local Testing
+
+Without publishing to npm:
+
 ```bash
 bun install
-bun run index.ts my-service
+npm pack
+bunx ./create-svc-*.tgz my-service
+```
+
+For faster iteration against your working tree:
+
+```bash
+bun link
+bun link create-svc
+create-svc my-service
+```
+
+During scaffold, the generator can discover:
+
+- accessible GCP projects
+- open billing accounts
+
+Remote `bootstrap` and `deploy` use Neon credentials from `NEON_API_KEY`, or Vault via `VAULT_ADDR` plus `VAULT_TOKEN`, `VAULT_TOKEN_FILE`, or `~/.vault-token`.
+Provider runtime credentials can be supplied through environment variables or Vault paths under `secret/prod/providers/*`; generated Cloud Run services receive runtime values through app-project Secret Manager.
+
+Before running generated provisioning commands locally, authenticate `gcloud` on the machine:
+
+```bash
+gcloud auth login
 ```
 
-The generated service supports:
+## Generated Backend Package
+
+First local run:
 
 ```bash
-bun dev
-bun gen
-bun lint
-bun test
+docker compose up -d
+```
+
+For Bun variants:
+
+```bash
+bun run migrate
+bun run dev
+bun run gen
+bun run lint
+bun run test
+bun run bootstrap
 bun run deploy
+bun run cleanup
+```
+
+For Go variants:
+
+```bash
+make migrate
+make dev
+make gen
+make lint
+make test
+make bootstrap
+make deploy
+make cleanup
 ```
 
+The generated package is intended to be consumed by a Next.js web app or a mobile client over HTTPS. In v1, production is expected to live at `https://api.<appname>.anmho.com`, while preview and personal environments keep using deterministic Cloud Run URLs.
+
+The microservice profile is moving toward a small waitlist/launch service example. The current generated plumbing still includes:
+
+- Postgres-backed `users`, `conversations`, `conversation_participants`, and `messages`
+- image attachment upload/finalize plumbing via GCS
+- generic typed webhook ingestion on plain HTTP
+
 ## Development
 
 ```bash
-bun test src
+bun install
+bun test src scripts
+bun run index.ts my-service
+```
+
+Validate the generated app matrix against local Docker Compose Postgres:
+
+```bash
+bun run validate:generated
+bun run validate:generated -- --variant bun-hono
+bun run validate:generated -- --variant go-connectrpc --keep
+```
+
+The validation harness scaffolds generated apps into ignored `bin/generated/run-*` workspaces, runs the generated public commands, starts the local server, and smoke-tests health or typed ConnectRPC clients where applicable.
+
+## npm Trusted Publishing
+
+`create-svc` is set up for npm trusted publishing from GitHub Actions, so there is no long-lived npm publish token to store in Vault.
+
+Repository workflow:
+- [publish.yml](.github/workflows/publish.yml)
+- Trigger: Git tags matching `v*`
+- CI runtime: Bun for install/test/typecheck, npm for the final publish step
+
+npm package setup still has to be configured once in the npm UI to trust this repository and workflow:
+
+1. Open the `create-svc` package settings on npm.
+2. Go to `Settings` -> `Trusted Publisher`.
+3. Select `GitHub Actions`.
+4. Enter:
+   - Organization or user: `anmho`
+   - Repository: `create-svc`
+   - Workflow filename: `publish.yml`
+5. Save the trusted publisher.
+
+After that, publishing is:
+
+```bash
+git tag v0.1.10
+git push origin v0.1.10
 ```
+
+The GitHub Actions workflow will authenticate with npm via OIDC and run `npm publish` without an npm token.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-svc",
-  "version": "0.1.8",
-  "description": "Bun-authored CLI to scaffold Go Cloud Run services with Chi, ConnectRPC, Vault, and Cloudflare examples.",
+  "version": "0.1.10",
+  "description": "Local backend bootstrap CLI for Bun-first Cloud Run API services with Neon and Vault provisioning.",
   "module": "index.ts",
   "type": "module",
   "license": "MIT",
@@ -18,7 +18,9 @@
   ],
   "scripts": {
     "dev": "bun run index.ts",
-    "test": "bun test src"
+    "test": "bun test src scripts",
+    "validate:generated": "bun run ./scripts/validate-generated.ts",
+    "typecheck": "bunx tsc --noEmit"
   },
   "repository": {
     "type": "git",
@@ -30,12 +32,15 @@
   },
   "keywords": [
     "bun",
+    "backend",
     "cloud-run",
     "connectrpc",
-    "go",
     "grpc",
+    "hono",
+    "monorepo",
     "scaffold"
   ],
+  "packageManager": "bun@1.3.2",
   "devDependencies": {
     "@types/bun": "latest"
   },

package/src/cli.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from "bun:test";
 import { mkdir } from "node:fs/promises";
-import { assertDiscoveryReady, normalizeValidationResult, validateServiceNameInput } from "./cli";
+import { assertDiscoveryReady, normalizeValidationResult, parseArgs, validateServiceNameInput } from "./cli";
 
 test("normalizeValidationResult converts success to undefined", () => {
   expect(normalizeValidationResult(true)).toBeUndefined();
@@ -10,17 +10,38 @@ test("normalizeValidationResult preserves validation errors", () => {
   expect(normalizeValidationResult("Service name is required")).toBe("Service name is required");
 });
 
-test("assertDiscoveryReady requires Neon discovery to succeed", () => {
-  expect(() =>
+test("assertDiscoveryReady no longer blocks scaffold when remote discovery is unavailable", () => {
+  expect(
     assertDiscoveryReady({
       projects: [],
       billingAccounts: [],
-      warnings: [],
-      neonError: "Vault secret resolution requires VAULT_ADDR, VAULT_TOKEN, and a secret path",
+      warnings: ["Skipping GCP project discovery: gcloud not installed"],
     })
-  ).toThrow(
-    "Neon discovery is required before scaffolding. Set NEON_API_KEY, or use Vault by providing VAULT_ADDR and VAULT_TOKEN. Optional overrides: VAULT_SECRET_MOUNT, VAULT_NEON_API_KEY_PATH, VAULT_NEON_API_KEY_FIELD."
-  );
+  ).toEqual({
+    projects: [],
+    billingAccounts: [],
+    warnings: ["Skipping GCP project discovery: gcloud not installed"],
+  });
+});
+
+test("parseArgs defaults to the microservice profile and treats bootstrap as strict deploy", () => {
+  expect(parseArgs(["launch-api", "--yes"])).toMatchObject({
+    directory: "launch-api",
+    profile: "microservice",
+    yes: true,
+  });
+  expect(parseArgs(["launch-api", "--yes"]).autoDeploy).toBeUndefined();
+
+  expect(parseArgs(["launch-api", "--profile", "microservice", "--bootstrap"])).toMatchObject({
+    directory: "launch-api",
+    profile: "microservice",
+    autoDeploy: true,
+  });
+});
+
+test("parseArgs rejects the moved app profile with private template guidance", () => {
+  expect(() => parseArgs(["tracker", "--profile=app", "--yes"])).toThrow("anmho/create-app-consumer");
+  expect(() => parseArgs(["tracker", "--profile", "app", "--yes"])).toThrow("anmho/create-app-saas");
 });
 
 test("validateServiceNameInput rejects a taken target directory", async () => {

package/src/cli.ts

@@ -5,6 +5,7 @@ import {
   intro,
   isCancel,
   log,
+  note,
   outro,
   select,
   spinner,
@@ -16,7 +17,6 @@ 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,
@@ -27,6 +27,7 @@ import {
   type GcpProjectMode,
   type Runtime,
 } from "./naming";
+import { parseProfile, type Profile } from "./profiles";
 import {
   DirectoryConflictError,
   assertTargetDirectoryIsEmpty,
@@ -38,13 +39,14 @@ type ParsedArgs = {
   directory?: string;
   runtime?: Runtime;
   framework?: Framework;
+  modulePath?: string;
   gcpProjectMode?: GcpProjectMode;
   gcpProject?: string;
-  githubRepo?: string;
   region?: string;
   billingAccount?: string;
   quotaProjectId?: string;
   autoDeploy?: boolean;
+  profile: Profile;
   yes: boolean;
   help: boolean;
 };
@@ -52,10 +54,6 @@ type ParsedArgs = {
 type DiscoveryState = {
   projects: GcpProject[];
   billingAccounts: BillingAccount[];
-  neonProjectId?: string;
-  neonBaseBranchId?: string;
-  neonBaseBranchName?: string;
-  neonError?: string;
   warnings: string[];
 };
 
@@ -69,7 +67,7 @@ export async function run(argv: string[]) {
       return;
     }
 
-    intro(`${pc.bold("create-svc")} ${pc.dim("Cloud Run scaffold")}`);
+    intro(`${pc.bold("create-svc")} ${pc.dim("backend bootstrap")}`);
 
     const config = await resolveConfig(args);
     const targetDir = resolve(process.cwd(), config.directory);
@@ -79,8 +77,8 @@ export async function run(argv: string[]) {
         `${pc.bold("Output")}: ${targetDir}`,
         `${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`,
       ].join("\n"),
       "Scaffold"
     );
@@ -90,7 +88,7 @@ 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 shouldRunPostScaffoldFlow = config.autoDeploy;
     if (shouldRunPostScaffoldFlow) {
       const automationSpinner = spinner();
       automationSpinner.start("Running post-scaffold automation");
@@ -103,13 +101,21 @@ export async function run(argv: string[]) {
       }
     }
 
+    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}`)}`,
+        `Local DB: ${pc.cyan("docker compose up -d")}`,
+        `Migrate: ${pc.cyan(isBun ? "bun run migrate" : "make migrate")}`,
+        `Local dev: ${pc.cyan(isBun ? "bun run dev" : "make dev")}`,
+        `Bootstrap: ${pc.cyan(isBun ? "bun run bootstrap" : "make bootstrap")}`,
+        `Deploy: ${pc.cyan(isBun ? "bun run deploy" : "make deploy")}`,
+        `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}`)}`,
       ].join("\n")
     );
   } catch (error) {
@@ -117,8 +123,9 @@ export async function run(argv: string[]) {
   }
 }
 
-function parseArgs(argv: string[]): ParsedArgs {
+export function parseArgs(argv: string[]): ParsedArgs {
   const parsed: ParsedArgs = {
+    profile: "microservice",
     yes: false,
     help: false,
   };
@@ -173,6 +180,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 +225,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;
@@ -243,6 +260,11 @@ function parseArgs(argv: string[]): ParsedArgs {
       continue;
     }
 
+    if (token === "--bootstrap") {
+      parsed.autoDeploy = true;
+      continue;
+    }
+
     if (token === "--no-auto-deploy") {
       parsed.autoDeploy = false;
       continue;
@@ -267,10 +289,9 @@ export async function resolveConfig(args: ParsedArgs): Promise<ScaffoldConfig> {
   const defaults = deriveDefaults(serviceName);
   const runtime = await resolveRuntime(args);
   const framework = await resolveFramework(args, runtime);
-  const discovery = await discoveryPromise;
-  assertDiscoveryReady(discovery);
+  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);
@@ -293,41 +314,51 @@ export async function resolveConfig(args: ParsedArgs): Promise<ScaffoldConfig> {
   return {
     directory,
     serviceName,
+    modulePath,
     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",
     neonDatabaseName: defaults.neonDatabaseName,
+    apiHostname: defaults.apiHostname,
     generatorRoot: resolve(dirname(fileURLToPath(import.meta.url)), ".."),
   };
 }
 
+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 resolveRuntime(args: ParsedArgs): Promise<Runtime> {
   if (args.runtime) {
     return args.runtime;
   }
 
   if (args.yes) {
-    return "go";
+    return "bun";
   }
 
   const value = await select({
     message: "Runtime",
-    initialValue: "go",
+    initialValue: "bun",
     options: [
-      { value: "go", label: "Go", hint: "Default" },
-      { value: "bun", label: "Bun" },
+      { value: "bun", label: "Bun", hint: "Default" },
+      { value: "go", label: "Go" },
     ],
   });
 
@@ -336,13 +367,13 @@ 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];
   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}`);
@@ -367,7 +398,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 +535,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 +559,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 +570,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 +585,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 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}`);
@@ -641,17 +668,23 @@ Usage:
   bun run index.ts [directory] [options]
 
 Options:
+  --profile <microservice>        Compatibility no-op; create-svc only generates microservices
   --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
+  --bootstrap                     Alias for --auto-deploy
   --no-auto-deploy                Scaffold only
   --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/naming.test.ts

@@ -1,14 +1,16 @@
 import { expect, test } from "bun:test";
-import { buildGcpProjectOptions, compactDatabaseName, compactIdentifier, deriveDefaults } from "./naming";
+import { buildGcpProjectOptions, compactDatabaseName, compactIdentifier, deriveDefaults, deriveLocalPostgresPort } from "./naming";
 
 test("deriveDefaults uses the service name for project, repo, and database naming", () => {
   expect(deriveDefaults("edge-api")).toEqual({
     serviceName: "edge-api",
     projectName: "edge-api",
     projectId: "anmho-edge-api",
-    githubRepo: "anmho/edge-api",
     cloudRunService: "edge-api",
     neonDatabaseName: "edge_api",
+    localDatabasePort: deriveLocalPostgresPort("edge-api"),
+    apiHostname: "api.edge-api.anmho.com",
+    modulePath: "example.com/edge-api",
   });
 });
 

package/src/naming.ts

@@ -54,6 +54,12 @@ export function compactDatabaseName(serviceName: string) {
   });
 }
 
+export function deriveLocalPostgresPort(serviceName: string) {
+  const normalized = slugify(serviceName) || "my-service";
+  const hash = Number.parseInt(shortHash(normalized).slice(0, 4), 16);
+  return String(55000 + (hash % 1000));
+}
+
 export function deriveDefaults(serviceName: string) {
   const normalizedServiceName = slugify(serviceName) || "my-service";
 
@@ -61,9 +67,11 @@ export function deriveDefaults(serviceName: string) {
     serviceName: normalizedServiceName,
     projectName: normalizedServiceName,
     projectId: compactIdentifier(`anmho-${normalizedServiceName}`, 30),
-    githubRepo: `anmho/${normalizedServiceName}`,
     cloudRunService: normalizedServiceName,
     neonDatabaseName: compactDatabaseName(normalizedServiceName),
+    localDatabasePort: deriveLocalPostgresPort(normalizedServiceName),
+    apiHostname: `api.${normalizedServiceName}.anmho.com`,
+    modulePath: `example.com/${normalizedServiceName}`,
   };
 }