create-svc 0.1.12 → 0.1.14

package/README.md

@@ -23,6 +23,13 @@ npm: <https://www.npmjs.com/package/create-svc>
 service create my-service
 ```
 
+That creates `./my-service` by default. To write somewhere else while keeping
+the service id as `my-service`, pass `--dir`:
+
+```bash
+service create my-service --dir /Users/andrewho/repos/projects/my-service
+```
+
 Inside a generated service repo, the same command operates that repo:
 
 ```bash
@@ -34,7 +41,7 @@ service deploy
 To install from npm:
 
 ```bash
-bun add -g create-svc
+npm install -g create-svc
 ```
 
 For the strict one-command production path:
@@ -43,14 +50,19 @@ For the strict one-command production path:
 service create my-service --yes
 ```
 
+By default, that scaffolds the repo, installs dependencies, runs the generated
+repo's `service create`, and then runs `service deploy`. Pass
+`--no-auto-deploy` for scaffold-only generation.
+
 `--profile microservice` is accepted as a compatibility no-op. App workspaces live outside this package in private app template repositories.
 
 By default, a standalone generated service is initialized as a git repository,
 committed with `Initial commit`, created as a private GitHub repository at
-`anmho/<service-name>`, and pushed to `origin/main`. If the target directory is
-inside an existing git worktree, `service` skips git and GitHub setup so the
-parent repository remains in control. Pass `--no-git` to skip all git and GitHub
-side effects.
+`https://github.com/anmho/<service_id>`, and pushed to `origin/main`. Go
+services also default their module path to `github.com/anmho/<service_id>`.
+If the target directory is inside an existing git worktree, `service` skips git
+and GitHub setup so the parent repository remains in control. Pass `--no-git`
+to skip all git and GitHub side effects.
 
 ## Local Testing
 
@@ -59,7 +71,8 @@ Without publishing to npm:
 ```bash
 bun install
 npm pack
-bunx ./create-svc-*.tgz create my-service
+npm install -g ./create-svc-*.tgz
+service create my-service
 ```
 
 For faster iteration against your working tree:

package/package.json

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

package/src/cli.test.ts

@@ -2,8 +2,10 @@ import { expect, test } from "bun:test";
 import { mkdir } from "node:fs/promises";
 import {
   assertDiscoveryReady,
+  formatScaffoldHelp,
   normalizeValidationResult,
   parseArgs,
+  resolveAutoDeploy,
   validateTargetRuntimeFramework,
   validateServiceNameInput,
 } from "./cli";
@@ -32,12 +34,12 @@ test("assertDiscoveryReady no longer blocks scaffold when remote discovery is un
 
 test("parseArgs defaults to microservice and cloudrun target", () => {
   expect(parseArgs(["launch-api", "--yes"])).toMatchObject({
-    directory: "launch-api",
+    serviceName: "launch-api",
     profile: "microservice",
     yes: true,
   });
   expect(parseArgs(["launch-api", "--target", "workers", "--yes"])).toMatchObject({
-    directory: "launch-api",
+    serviceName: "launch-api",
     target: "workers",
     yes: true,
   });
@@ -47,6 +49,33 @@ test("parseArgs defaults to microservice and cloudrun target", () => {
   expect(() => parseArgs(["launch-api", "--profile", "microservice", "--bootstrap"])).toThrow("Unknown argument");
 });
 
+test("resolveAutoDeploy defaults to one-shot create and deploy", () => {
+  expect(resolveAutoDeploy(undefined)).toBeTrue();
+  expect(resolveAutoDeploy(true)).toBeTrue();
+  expect(resolveAutoDeploy(false)).toBeFalse();
+});
+
+test("parseArgs supports an explicit output directory", () => {
+  expect(parseArgs(["launch-api", "--dir", "/tmp/generated-launch-api", "--yes"])).toMatchObject({
+    serviceName: "launch-api",
+    directory: "/tmp/generated-launch-api",
+    yes: true,
+  });
+  expect(parseArgs(["--dir=/tmp/generated-launch-api", "--yes"])).toMatchObject({
+    directory: "/tmp/generated-launch-api",
+    yes: true,
+  });
+});
+
+test("formatScaffoldHelp is compact and starts at usage", () => {
+  const help = formatScaffoldHelp();
+  expect(help.startsWith("Usage:\n")).toBeTrue();
+  expect(help).not.toContain("\n\n\n");
+  expect(help).not.toContain("│");
+  expect(help).toContain("service create <service_id> [options]");
+  expect(help).toContain("--dir <path>");
+});
+
 test("parseArgs rejects the removed app profile", () => {
   expect(() => parseArgs(["tracker", "--profile=app", "--yes"])).toThrow("app profile has moved");
 });

package/src/cli.ts

@@ -15,8 +15,13 @@ import pc from "picocolors";
 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 { buildDeploymentVerificationCommands, runPostScaffoldFlow } from "./post-scaffold";
+import {
+  bootstrapGitHubRepository,
+  buildGitBootstrapConfig,
+  commitAndPushGeneratedArtifacts,
+  type GitBootstrapResult,
+} from "./git-bootstrap";
 import { listOpenBillingAccounts, listAccessibleProjects, type BillingAccount, type GcpProject } from "./gcp";
 import {
   BILLING_ACCOUNT_DEFAULT,
@@ -39,6 +44,7 @@ import {
 } from "./scaffold";
 
 type ParsedArgs = {
+  serviceName?: string;
   directory?: string;
   target?: DeployTarget;
   runtime?: Runtime;
@@ -50,8 +56,6 @@ type ParsedArgs = {
   billingAccount?: string;
   quotaProjectId?: string;
   autoDeploy?: boolean;
-  autoUpdate?: boolean;
-  noUpdateCheck?: boolean;
   noGit?: boolean;
   profile: Profile;
   yes: boolean;
@@ -74,8 +78,6 @@ export async function run(argv: string[]) {
       return;
     }
 
-    await maybeCheckForUpdate(args);
-
     intro(`${pc.bold("service")} ${pc.dim("microservice bootstrap")}`);
 
     const config = await resolveConfig(args);
@@ -130,27 +132,75 @@ export async function run(argv: string[]) {
       }
     }
 
-    const isBun = config.runtime === "bun";
-    outro(
-      [
-        `Next: ${pc.cyan(`cd ${config.directory}`)}`,
-        `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("service create")}`,
-        `Deploy: ${pc.cyan("service deploy")}`,
-        config.git.enabled ? `Repository: ${pc.cyan(`https://github.com/anmho/${config.git.repository}`)}` : undefined,
-        `Personal env: ${pc.cyan(
-          `service deploy --environment personal --name ${config.serviceName}`
-        )}`,
-        `Production API: ${pc.cyan(`https://${config.apiHostname}`)}`,
-      ].filter(Boolean).join("\n")
-    );
+    outro(config.autoDeploy ? "Created and deployed" : "Created");
+    console.log(formatCompletionSummary(config, targetDir, gitResult));
   } catch (error) {
     handleCliError(error);
   }
 }
 
+function formatCompletionSummary(config: ScaffoldConfig, targetDir: string, gitResult: GitBootstrapResult) {
+  const isBun = config.runtime === "bun";
+  const devCommand = isBun ? "bun run dev" : "make dev";
+  const migrateCommand = isBun ? "bun run migrate" : "make migrate";
+  const lifecycleCommands: Array<[string, string]> = config.autoDeploy
+    ? [
+        ["service deploy", "Deploys later changes."],
+        [`service deploy --environment personal --name ${config.serviceName}`, "Deploys your personal environment."],
+      ]
+    : [
+        ["service create", "Provisions auth, database, migrations, and the first deploy."],
+        ["service deploy", "Deploys later changes."],
+      ];
+  const repository =
+    gitResult.status === "created"
+      ? gitResult.url
+      : config.git.enabled
+        ? `https://github.com/${config.git.owner}/${config.git.repository}`
+        : undefined;
+
+  return [
+    "",
+    `Success! Created ${config.serviceName} at ${targetDir}`,
+    "",
+    "Inside that directory, you can run:",
+    formatCommand(devCommand, "Starts local development."),
+    formatCommand(migrateCommand, "Applies local database migrations."),
+    ...lifecycleCommands.map(([command, description]) => formatCommand(command, description)),
+    "",
+    "Control-plane defaults:",
+    `  Auth issuer: https://auth.anmho.com/api/auth`,
+    `  Auth resource: api://${config.serviceName}`,
+    `  Auth token URL: https://auth.anmho.com/api/auth/oauth2/token`,
+    `  Temporal: disabled by default`,
+    `  Temporal address: localhost:7233`,
+    `  Temporal task queue: ${config.serviceName}`,
+    `  Temporal API key secret: ${config.serviceName}-temporal-api-key`,
+    config.runtime === "go" ? `  Go module: ${config.modulePath}` : undefined,
+    "",
+    config.autoDeploy ? "Verified after deploy:" : "After deploy, verify with:",
+    ...buildDeploymentVerificationCommands(config).map(formatShellCommand),
+    "",
+    "We suggest that you begin by typing:",
+    "",
+    `  cd ${config.directory}`,
+    `  ${devCommand}`,
+    "",
+    repository ? `Repository: ${repository}` : undefined,
+    `Production API: https://${config.apiHostname}`,
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+function formatCommand(command: string, description: string) {
+  return [`  ${command}`, `    ${description}`].join("\n");
+}
+
+function formatShellCommand(command: { command: string; args: string[] }) {
+  return `  ${[command.command, ...command.args].join(" ")}`;
+}
+
 export function parseArgs(argv: string[]): ParsedArgs {
   const parsed: ParsedArgs = {
     profile: "microservice",
@@ -164,8 +214,8 @@ export function parseArgs(argv: string[]): ParsedArgs {
       continue;
     }
 
-    if (!token.startsWith("-") && !parsed.directory) {
-      parsed.directory = token;
+    if (!token.startsWith("-") && !parsed.serviceName) {
+      parsed.serviceName = token;
       continue;
     }
 
@@ -188,23 +238,23 @@ export function parseArgs(argv: string[]): ParsedArgs {
       continue;
     }
 
-    if (token === "--auto-update") {
-      parsed.autoUpdate = true;
+    if (token === "--no-git") {
+      parsed.noGit = true;
       continue;
     }
 
-    if (token === "--no-update-check") {
-      parsed.noUpdateCheck = true;
+    if (token === "--runtime") {
+      parsed.runtime = readValue() as Runtime;
       continue;
     }
 
-    if (token === "--no-git") {
-      parsed.noGit = true;
+    if (token === "--dir") {
+      parsed.directory = readValue();
       continue;
     }
 
-    if (token === "--runtime") {
-      parsed.runtime = readValue() as Runtime;
+    if (token.startsWith("--dir=")) {
+      parsed.directory = token.slice("--dir=".length);
       continue;
     }
 
@@ -324,71 +374,8 @@ export 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 inferredName = slugify(args.serviceName ?? basename(args.directory ?? "my-service"));
   const serviceName = args.yes
     ? inferredName
     : await promptText("Service name", inferredName, (value) => validateServiceNameInput(value, args.directory));
@@ -704,11 +691,11 @@ function chooseBillingAccount(input: string | undefined, accounts: BillingAccoun
   return accounts[0]?.name ?? BILLING_ACCOUNT_DEFAULT;
 }
 
-function resolveAutoDeploy(value: boolean | undefined) {
+export function resolveAutoDeploy(value: boolean | undefined) {
   if (value !== undefined) {
     return value;
   }
-  return false;
+  return true;
 }
 
 async function promptText(
@@ -823,29 +810,37 @@ export function validateServiceNameInput(rawValue: string, directoryOverride?: s
 }
 
 function printHelp() {
-  log.message(`
-Usage:
-  service create [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
-  --billing-account <name>        Billing account resource name
-  --quota-project <id>            Billing quota project for gcloud calls
-  --region <region>               Cloud Run region
-  --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
-`);
+  console.log(formatScaffoldHelp());
+}
+
+export function formatScaffoldHelp() {
+  return [
+    "Usage:",
+    "  service create <service_id> [options]",
+    "",
+    "Examples:",
+    "  service create waitlist-api --target cloudrun --runtime bun --framework hono",
+    "  service create waitlist-api --auto-deploy",
+    "",
+    "Options:",
+    "  --dir <path>                    Output directory; defaults to ./<service_id>",
+    "  --target <cloudrun|workers>     Deploy target for the generated service",
+    "  --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",
+    "  --billing-account <name>        Billing account resource name",
+    "  --quota-project <id>            Billing quota project for gcloud calls",
+    "  --region <region>               Cloud Run region",
+    "  --auto-deploy                   Scaffold, run service create, then service deploy (default)",
+    "  --no-auto-deploy                Scaffold only",
+    "  --no-git                        Skip default private GitHub repo: anmho/<service_id>",
+    "  --yes, -y                       Accept defaults without prompts",
+    "  --help, -h                      Show this message",
+    "",
+    "Inside a generated service repo, run service --help for create, deploy, doctor, auth, and sdk commands.",
+  ].join("\n");
 }
 
 function matchesProject(project: GcpProject, query: string) {

package/src/git-bootstrap.ts

@@ -30,19 +30,21 @@ export async function bootstrapGitHubRepository(targetDir: string, config: GitBo
     return { status: "skipped-existing-worktree", root: existingRoot };
   }
 
-  run(["git", "--version"], targetDir, "git is required to initialize the generated repository");
-  run(["gh", "--version"], targetDir, "GitHub CLI `gh` is required to create the generated repository");
-  run(["gh", "auth", "status"], targetDir, "Authenticate GitHub CLI with `gh auth login` before creating the repository");
+  run(["git", "--version"], targetDir, "git is required to initialize the generated repository", { quiet: true });
+  run(["gh", "--version"], targetDir, "GitHub CLI `gh` is required to create the generated repository", { quiet: true });
+  run(["gh", "auth", "status"], targetDir, "Authenticate GitHub CLI with `gh auth login` before creating the repository", { quiet: true });
 
-  run(["git", "init", "-b", "main"], targetDir);
+  run(["git", "init", "-b", "main", "--quiet"], targetDir);
   run(["git", "add", "."], targetDir);
 
   if (hasStagedChanges(targetDir)) {
-    run(["git", "commit", "-m", "Initial commit"], targetDir);
+    run(["git", "commit", "--quiet", "-m", "Initial commit"], targetDir);
   }
 
   const repository = `${config.owner}/${config.repository}`;
-  run(["gh", "repo", "create", repository, "--private", "--source", ".", "--remote", "origin", "--push"], targetDir);
+  run(["gh", "repo", "create", repository, "--private", "--source", ".", "--remote", "origin", "--push"], targetDir, undefined, {
+    quiet: true,
+  });
 
   return {
     status: "created",
@@ -55,8 +57,8 @@ export function commitAndPushGeneratedArtifacts(targetDir: string, message: stri
   if (!hasStagedChanges(targetDir)) {
     return { committed: false };
   }
-  run(["git", "commit", "-m", message], targetDir);
-  run(["git", "push"], targetDir);
+  run(["git", "commit", "--quiet", "-m", message], targetDir);
+  run(["git", "push", "--quiet"], targetDir, undefined, { quiet: true });
   return { committed: true };
 }
 
@@ -94,17 +96,18 @@ function hasStagedChanges(cwd: string) {
   return result.exitCode === 1;
 }
 
-function run(command: string[], cwd: string, message?: string) {
+function run(command: string[], cwd: string, message?: string, options: { quiet?: boolean } = {}) {
   const result = Bun.spawnSync(command, {
     cwd,
     stdin: "inherit",
-    stdout: "inherit",
+    stdout: options.quiet ? "pipe" : "inherit",
     stderr: "pipe",
   });
   if (result.exitCode === 0) {
     return;
   }
 
+  const output = result.stdout?.toString().trim() ?? "";
   const detail = result.stderr.toString().trim();
-  throw new Error([message, `Command failed: ${command.join(" ")}`, detail].filter(Boolean).join("\n"));
+  throw new Error([message, `Command failed: ${command.join(" ")}`, output, detail].filter(Boolean).join("\n"));
 }

package/src/naming.test.ts

@@ -11,7 +11,7 @@ test("deriveDefaults uses the service name for project, repo, and database namin
     neonDatabaseName: "edge_api",
     localDatabasePort: deriveLocalPostgresPort("edge-api"),
     apiHostname: "api.edge-api.anmho.com",
-    modulePath: "example.com/edge-api",
+    modulePath: "github.com/anmho/edge-api",
   });
 });
 

package/src/naming.ts

@@ -94,7 +94,7 @@ export function deriveDefaults(serviceName: string) {
     neonDatabaseName: compactDatabaseName(normalizedServiceName),
     localDatabasePort: deriveLocalPostgresPort(normalizedServiceName),
     apiHostname: `api.${normalizedServiceName}.anmho.com`,
-    modulePath: `example.com/${normalizedServiceName}`,
+    modulePath: `github.com/anmho/${normalizedServiceName}`,
   };
 }
 

package/src/post-scaffold.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { buildPostScaffoldCommands } from "./post-scaffold";
+import { buildDeploymentVerificationCommands, buildPostScaffoldCommands } from "./post-scaffold";
 
 describe("buildPostScaffoldCommands", () => {
   test("runs create and deploy for HTTP services", () => {
@@ -17,3 +17,19 @@ describe("buildPostScaffoldCommands", () => {
     ]);
   });
 });
+
+describe("buildDeploymentVerificationCommands", () => {
+  test("uses curl health checks for HTTP services", () => {
+    expect(buildDeploymentVerificationCommands({ apiHostname: "api.launch.anmho.com", framework: "hono", runtime: "bun" })).toEqual([
+      { command: "curl", args: ["--fail", "--show-error", "--silent", "https://api.launch.anmho.com/healthz"] },
+      { command: "curl", args: ["--fail", "--show-error", "--silent", "https://api.launch.anmho.com/readyz"] },
+    ]);
+  });
+
+  test("uses grpcurl for Go ConnectRPC services", () => {
+    expect(buildDeploymentVerificationCommands({ apiHostname: "api.launch.anmho.com", framework: "connectrpc", runtime: "go" })).toContainEqual({
+      command: "grpcurl",
+      args: ["api.launch.anmho.com:443", "list"],
+    });
+  });
+});

package/src/post-scaffold.ts

@@ -4,6 +4,7 @@ type CommandOptions = {
   cwd: string;
   allowFailure?: boolean;
   input?: string;
+  quiet?: boolean;
 };
 
 type CommandResult = {
@@ -26,12 +27,32 @@ export async function runPostScaffoldFlow(config: ScaffoldConfig, cwd: string) {
     for (const command of buildPostScaffoldCommands(config)) {
       run(command.command, command.args, { cwd });
     }
-    return { message: "Dependencies installed, service created, and service deployed" };
+    for (const command of buildDeploymentVerificationCommands(config)) {
+      run(command.command, command.args, { cwd, quiet: true });
+    }
+    return { message: "Dependencies installed, service created, service deployed, and production health verified" };
   }
 
   return { message: "Backend package generated" };
 }
 
+export function buildDeploymentVerificationCommands(
+  config: Pick<ScaffoldConfig, "apiHostname" | "framework" | "runtime">
+): PostScaffoldCommand[] {
+  const origin = `https://${config.apiHostname}`;
+  return [
+    { command: "curl", args: ["--fail", "--show-error", "--silent", `${origin}/healthz`] },
+    { command: "curl", args: ["--fail", "--show-error", "--silent", `${origin}/readyz`] },
+    ...(config.framework === "connectrpc"
+      ? [
+          config.runtime === "go"
+            ? { command: "grpcurl", args: [`${config.apiHostname}:443`, "list"] }
+            : { command: "curl", args: ["--fail", "--show-error", "--silent", `${origin}/debug/connectrpc`] },
+        ]
+      : []),
+  ];
+}
+
 export function buildPostScaffoldCommands(config: Pick<ScaffoldConfig, "framework">): PostScaffoldCommand[] {
   return [
     ...(config.framework === "connectrpc" ? [{ command: "bun", args: ["run", "service", "--", "sdk", "build"] }] : []),
@@ -56,8 +77,8 @@ function run(command: string, args: string[], options: CommandOptions): CommandR
     cwd: options.cwd,
     env: process.env,
     stdin: options.input === undefined ? undefined : encoder.encode(options.input),
-    stdout: options.allowFailure ? "pipe" : "inherit",
-    stderr: options.allowFailure ? "pipe" : "inherit",
+    stdout: options.allowFailure || options.quiet ? "pipe" : "inherit",
+    stderr: options.allowFailure || options.quiet ? "pipe" : "inherit",
   });
 
   const stdout = result.stdout ? decoder.decode(result.stdout).trim() : "";

package/src/scaffold.test.ts

@@ -9,7 +9,7 @@ function baseConfig(overrides: Partial<ScaffoldConfig> = {}): ScaffoldConfig {
   return {
     directory: "svc",
     serviceName: "dns-api",
-    modulePath: "example.com/dns-api",
+    modulePath: "github.com/anmho/dns-api",
     target: "cloudrun",
     runtime: "bun",
     framework: "hono",
@@ -156,11 +156,17 @@ test("scaffolds all runtime/framework variants with shared cloudrun config", asy
 
     if (variant.runtime === "go") {
       const goMod = await Bun.file(join(generatedRoot, "go.mod")).text();
-      expect(goMod).toContain("module example.com/dns-api");
-      expect(goMod).not.toContain("module github.com/anmho/dns-api");
+      const packageJson = await Bun.file(join(generatedRoot, "package.json")).text();
+      expect(goMod).toContain("module github.com/anmho/dns-api");
+      expect(goMod).not.toContain("module example.com/dns-api");
+      expect(packageJson).toContain('"dev": "make dev"');
+      expect(packageJson).toContain('"migrate": "make migrate"');
+      expect(packageJson).toContain('"create": "bun run ./scripts/cloudrun/cli.ts create"');
+      expect(packageJson).toContain('"deploy": "bun run ./scripts/cloudrun/cli.ts deploy"');
+      expect(packageJson).toContain('"destroy": "bun run ./scripts/cloudrun/cli.ts destroy"');
 
       const mainGo = await Bun.file(join(generatedRoot, "cmd", "server", "main.go")).text();
-      expect(mainGo).toContain("example.com/dns-api");
+      expect(mainGo).toContain("github.com/anmho/dns-api");
       if (variant.framework === "connectrpc") {
         expect(goMod).toContain("connectrpc.com/connect");
         expect(mainGo).toContain("NewWaitlistService");
@@ -202,7 +208,8 @@ test("scaffolds all runtime/framework variants with shared cloudrun config", asy
       expect(packageJson).toContain('"auth": "bun run ./scripts/cloudrun/cli.ts auth"');
       expect(packageJson).toContain('"destroy": "bun run ./scripts/cloudrun/cli.ts destroy"');
       const serviceCli = await Bun.file(join(generatedRoot, "scripts", "cloudrun", "cli.ts")).text();
-      expect(serviceCli).toContain("service <create|deploy|migrate|seed|dashboards|dns|doctor|destroy|auth|sdk>");
+      expect(serviceCli).toContain("service <command> [args]");
+      expect(serviceCli).toContain("Provision auth, database, migrations, and first deploy");
       expect(serviceCli).toContain("assertServiceNameAvailable(config.serviceName)");
       expect(serviceCli).toContain("ensureAuthResourceServer");
       expect(serviceCli).toContain('["resources", "push", "--path", "./grafana"]');

package/src/service.test.ts

@@ -2,7 +2,7 @@ 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, normalizeScaffoldArgs } from "./service";
+import { findGeneratedServiceRoot, generatedDependenciesInstalled, normalizeScaffoldArgs } from "./service";
 
 test("normalizeScaffoldArgs treats service create as the scaffold command outside a service repo", () => {
   expect(normalizeScaffoldArgs(["create", "launch-api", "--yes"])).toEqual(["launch-api", "--yes"]);
@@ -28,3 +28,14 @@ test("findGeneratedServiceRoot detects generated service context from nested dir
   expect(findGeneratedServiceRoot(nested)).toBe(serviceRoot);
   expect(findGeneratedServiceRoot(root)).toBeUndefined();
 });
+
+test("generatedDependenciesInstalled requires node_modules when package.json exists", async () => {
+  const root = await mkdtemp(join(tmpdir(), "create-svc-generated-deps-"));
+  expect(generatedDependenciesInstalled(root)).toBeTrue();
+
+  await writeFile(join(root, "package.json"), "{}");
+  expect(generatedDependenciesInstalled(root)).toBeFalse();
+
+  await mkdir(join(root, "node_modules"));
+  expect(generatedDependenciesInstalled(root)).toBeTrue();
+});

package/src/service.ts

@@ -48,6 +48,8 @@ function isGeneratedServiceRoot(path: string) {
 }
 
 function delegateToGeneratedService(serviceRoot: string, argv: string[]) {
+  ensureGeneratedDependencies(serviceRoot);
+
   const cliPath = existsSync(join(serviceRoot, "scripts", "cloudrun", "cli.ts"))
     ? "./scripts/cloudrun/cli.ts"
     : "./scripts/workers/cli.ts";
@@ -63,3 +65,27 @@ function delegateToGeneratedService(serviceRoot: string, argv: string[]) {
     process.exit(result.exitCode || 1);
   }
 }
+
+export function generatedDependenciesInstalled(serviceRoot: string) {
+  return !existsSync(join(serviceRoot, "package.json")) || existsSync(join(serviceRoot, "node_modules"));
+}
+
+function ensureGeneratedDependencies(serviceRoot: string) {
+  if (generatedDependenciesInstalled(serviceRoot)) {
+    return;
+  }
+
+  const result = Bun.spawnSync(["bun", "install", "--silent"], {
+    cwd: serviceRoot,
+    env: process.env,
+    stdin: "inherit",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  if (!result.success) {
+    const output = [result.stdout.toString().trim(), result.stderr.toString().trim()].filter(Boolean).join("\n");
+    console.error(["Failed to install generated service dependencies with bun install --silent", output].filter(Boolean).join("\n"));
+    process.exit(result.exitCode || 1);
+  }
+}

package/src/vault.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, expect, mock, test } from "bun:test";
 import { mkdir } from "node:fs/promises";
-import { readVaultSecret, resolveNeonApiKey, upsertVaultSecretFields } from "./vault";
+import { readVaultSecret, resolveNeonApiKey } from "./vault";
 
 const originalEnv = { ...process.env };
 
@@ -97,63 +97,3 @@ test("readVaultSecret falls back to ~/.vault-token", async () => {
     })
   ).resolves.toBe("vault-token");
 });
-
-test("upsertVaultSecretFields writes merged KV v2 data", async () => {
-  process.env.VAULT_ADDR = "https://vault.example.com";
-  process.env.VAULT_TOKEN = "token-123";
-
-  const requests: Array<{ method: string; url: string; body?: unknown }> = [];
-  const fetchMock = mock(async (input: string | URL | Request, init?: RequestInit) => {
-    const url = String(input);
-    requests.push({
-      method: init?.method ?? "GET",
-      url,
-      body: init?.body ? JSON.parse(String(init.body)) : undefined,
-    });
-
-    if ((init?.method ?? "GET") === "GET") {
-      return new Response(
-        JSON.stringify({
-          data: {
-            data: {
-              existing_field: "keep-me",
-            },
-          },
-        }),
-        { status: 200 }
-      );
-    }
-
-    return new Response(JSON.stringify({}), { status: 200 });
-  });
-
-  globalThis.fetch = fetchMock as unknown as typeof fetch;
-
-  await upsertVaultSecretFields({
-    path: "prod/providers/clerk",
-    fields: {
-      publishable_key: "pk_live_example",
-      secret_key: "sk_live_example",
-      webhook_secret: "whsec_example",
-    },
-  });
-
-  expect(requests).toEqual([
-    {
-      method: "GET",
-      url: "https://vault.example.com/v1/secret/data/prod/providers/clerk",
-    },
-    {
-      method: "POST",
-      url: "https://vault.example.com/v1/secret/data/prod/providers/clerk",
-      body: {
-        data: {
-          existing_field: "keep-me",
-          publishable_key: "pk_live_example",
-          secret_key: "sk_live_example",
-          webhook_secret: "whsec_example",
-        },
-      },
-    },
-  ]);
-});

package/src/vault.ts

@@ -13,14 +13,6 @@ type VaultSecretOptions = {
   field?: string;
 };
 
-type VaultWriteOptions = {
-  addr?: string;
-  token?: string;
-  mount?: string;
-  path: string;
-  fields: Record<string, string>;
-};
-
 export async function resolveNeonApiKey() {
   const direct = process.env.NEON_API_KEY?.trim();
   if (direct) {
@@ -34,59 +26,24 @@ export async function resolveNeonApiKey() {
 }
 
 export async function readVaultSecret(options: VaultSecretOptions = {}) {
-  const field = options.field?.trim() ?? "value";
-  const payload = await readVaultSecretData(options);
+  const addr = options.addr ?? process.env.VAULT_ADDR?.trim() ?? "";
+  const token = options.token ?? (await resolveVaultToken());
   const mount = options.mount ?? process.env.VAULT_SECRET_MOUNT?.trim() ?? DEFAULT_VAULT_SECRET_MOUNT;
   const path = options.path?.trim() ?? "";
-  const normalizedMount = mount.replace(/^\/+|\/+$/g, "");
-  const normalizedPath = path.replace(/^\/+/g, "");
-  const value = payload[field]?.trim();
-  if (!value) {
-    throw new Error(`Vault secret field ${field} is empty at ${normalizedMount}/${normalizedPath}`);
-  }
-
-  return value;
-}
-
-export async function readVaultSecretFields(options: VaultSecretOptions = {}) {
-  return readVaultSecretData(options);
-}
+  const field = options.field?.trim() ?? "value";
 
-export async function upsertVaultSecretFields(options: VaultWriteOptions) {
-  const connection = await resolveVaultConnection(options);
-  const url = vaultKv2Url(connection);
+  if (!addr || !token || !path) {
+    throw new Error("Vault secret resolution requires VAULT_ADDR, a Vault token, and a secret path");
+  }
 
-  const existing = await readVaultSecretData({ ...options, path: connection.normalizedPath }).catch((error) => {
-    if (error instanceof Error && error.message.startsWith("Vault read failed: 404")) {
-      return {};
-    }
-    throw error;
-  });
+  const normalizedAddr = addr.replace(/\/+$/g, "");
+  const normalizedMount = mount.replace(/^\/+|\/+$/g, "");
+  const normalizedPath = path.replace(/^\/+/g, "");
+  const url = `${normalizedAddr}/v1/${normalizedMount}/data/${normalizedPath}`;
 
   const response = await fetch(url, {
-    method: "POST",
     headers: {
-      "Content-Type": "application/json",
-      "X-Vault-Token": connection.token,
-    },
-    body: JSON.stringify({
-      data: {
-        ...existing,
-        ...trimFields(options.fields),
-      },
-    }),
-  });
-
-  if (!response.ok) {
-    throw new Error(`Vault write failed: ${response.status} ${response.statusText}`);
-  }
-}
-
-async function readVaultSecretData(options: VaultSecretOptions = {}) {
-  const connection = await resolveVaultConnection(options);
-  const response = await fetch(vaultKv2Url(connection), {
-    headers: {
-      "X-Vault-Token": connection.token,
+      "X-Vault-Token": token,
     },
   });
 
@@ -100,31 +57,12 @@ async function readVaultSecretData(options: VaultSecretOptions = {}) {
     };
   };
 
-  return payload.data?.data ?? {};
-}
-
-async function resolveVaultConnection(options: Omit<VaultWriteOptions, "fields"> | VaultSecretOptions) {
-  const addr = options.addr ?? process.env.VAULT_ADDR?.trim() ?? "";
-  const token = options.token ?? (await resolveVaultToken());
-  const mount = options.mount ?? process.env.VAULT_SECRET_MOUNT?.trim() ?? DEFAULT_VAULT_SECRET_MOUNT;
-  const path = options.path?.trim() ?? "";
-
-  if (!addr || !token || !path) {
-    throw new Error("Vault secret resolution requires VAULT_ADDR, a Vault token, and a secret path");
+  const value = payload.data?.data?.[field]?.trim();
+  if (!value) {
+    throw new Error(`Vault secret field ${field} is empty at ${normalizedMount}/${normalizedPath}`);
   }
 
-  const normalizedAddr = addr.replace(/\/+$/g, "");
-  const normalizedMount = mount.replace(/^\/+|\/+$/g, "");
-  const normalizedPath = path.replace(/^\/+/g, "");
-  return { normalizedAddr, normalizedMount, normalizedPath, token };
-}
-
-function vaultKv2Url(connection: Awaited<ReturnType<typeof resolveVaultConnection>>) {
-  return `${connection.normalizedAddr}/v1/${connection.normalizedMount}/data/${connection.normalizedPath}`;
-}
-
-function trimFields(fields: Record<string, string>) {
-  return Object.fromEntries(Object.entries(fields).map(([key, value]) => [key, value.trim()]));
+  return value;
 }
 
 async function resolveVaultToken() {

package/templates/shared/scripts/cloudrun/cli.ts

@@ -27,7 +27,7 @@ async function main(argv = Bun.argv.slice(2)) {
   const [command, ...rest] = argv;
 
   if (!command || command === "--help" || command === "-h" || command === "help") {
-    console.log("Usage: service <create|deploy|migrate|seed|dashboards|dns|doctor|destroy|auth|sdk> [args]");
+    console.log(formatHelp());
     return;
   }
 
@@ -92,7 +92,26 @@ async function main(argv = Bun.argv.slice(2)) {
     return;
   }
 
-  throw new Error("Usage: service <create|deploy|migrate|seed|dashboards|dns|doctor|destroy|auth|sdk> [args]");
+  throw new Error(`Unknown command: ${command}\n\n${formatHelp()}`);
+}
+
+function formatHelp() {
+  return [
+    "Usage:",
+    "  service <command> [args]",
+    "",
+    "Commands:",
+    "  create      Provision auth, database, migrations, and first deploy",
+    "  deploy      Deploy the current service",
+    "  migrate     Apply database migrations",
+    "  seed        Run the seed script when configured",
+    "  doctor      Check local tools and cloud access",
+    "  auth        Manage auth resource server and clients",
+    "  sdk         Build or publish generated SDK artifacts",
+    "  dns         Repair or inspect DNS mappings",
+    "  dashboards  Publish Grafana resources",
+    "  destroy     Remove service-managed cloud resources",
+  ].join("\n");
 }
 
 function runLanguageTask(task: "migrate", env?: Record<string, string | undefined>) {

package/templates/targets/workers/scripts/workers/cli.ts

@@ -18,7 +18,7 @@ async function main(argv = Bun.argv.slice(2)) {
   const [command, ...rest] = argv;
 
   if (!command || command === "--help" || command === "-h" || command === "help") {
-    console.log("Usage: service <create|deploy|migrate|seed|dashboards|dns|doctor|destroy|auth|sdk> [args]");
+    console.log(formatHelp());
     return;
   }
 
@@ -87,7 +87,25 @@ async function main(argv = Bun.argv.slice(2)) {
     throw new Error("SDK commands are only available for ConnectRPC services");
   }
 
-  throw new Error("Usage: service <create|deploy|migrate|seed|dashboards|dns|doctor|destroy|auth|sdk> [args]");
+  throw new Error(`Unknown command: ${command}\n\n${formatHelp()}`);
+}
+
+function formatHelp() {
+  return [
+    "Usage:",
+    "  service <command> [args]",
+    "",
+    "Commands:",
+    "  create      Provision auth, database, Hyperdrive, and first deploy",
+    "  deploy      Deploy the Worker",
+    "  migrate     Apply database schema",
+    "  seed        Report seed status",
+    "  doctor      Check local tools and cloud access",
+    "  auth        Manage auth resource server and clients",
+    "  dns         Show Workers custom-domain configuration",
+    "  dashboards  Publish Grafana resources",
+    "  destroy     Remove service-managed Worker resources",
+  ].join("\n");
 }
 
 function run(command: string, args: string[], options: { allowFailure?: boolean; capture?: boolean } = {}) {

package/templates/variants/go-chi/package.json

@@ -6,9 +6,17 @@
     "service": "./scripts/cloudrun/cli.ts"
   },
   "scripts": {
+    "dev": "make dev",
     "service": "bun run ./scripts/cloudrun/cli.ts",
+    "migrate": "make migrate",
+    "gen": "make gen",
+    "lint": "make lint",
+    "test": "make test",
+    "create": "bun run ./scripts/cloudrun/cli.ts create",
+    "deploy": "bun run ./scripts/cloudrun/cli.ts deploy",
     "auth": "bun run ./scripts/cloudrun/cli.ts auth",
-    "dashboards": "bun run ./scripts/cloudrun/cli.ts dashboards"
+    "dashboards": "bun run ./scripts/cloudrun/cli.ts dashboards",
+    "destroy": "bun run ./scripts/cloudrun/cli.ts destroy"
   },
   "dependencies": {
     "@anmho/authctl": "0.1.1",

package/templates/variants/go-connectrpc/package.json

@@ -6,9 +6,17 @@
     "service": "./scripts/cloudrun/cli.ts"
   },
   "scripts": {
+    "dev": "make dev",
     "service": "bun run ./scripts/cloudrun/cli.ts",
+    "migrate": "make migrate",
+    "gen": "make gen",
+    "lint": "make lint",
+    "test": "make test",
+    "create": "bun run ./scripts/cloudrun/cli.ts create",
+    "deploy": "bun run ./scripts/cloudrun/cli.ts deploy",
     "auth": "bun run ./scripts/cloudrun/cli.ts auth",
-    "dashboards": "bun run ./scripts/cloudrun/cli.ts dashboards"
+    "dashboards": "bun run ./scripts/cloudrun/cli.ts dashboards",
+    "destroy": "bun run ./scripts/cloudrun/cli.ts destroy"
   },
   "dependencies": {
     "@anmho/authctl": "0.1.1",