create-svc 0.1.10 → 0.1.11

package/src/cli.ts

@@ -16,13 +16,16 @@ 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 {
   BILLING_ACCOUNT_DEFAULT,
-  FRAMEWORKS_BY_RUNTIME,
   QUOTA_PROJECT_DEFAULT,
   deriveDefaults,
+  frameworksForTargetRuntime,
+  parseDeployTarget,
   slugify,
+  type DeployTarget,
   type Framework,
   type GcpProjectMode,
   type Runtime,
@@ -37,6 +40,7 @@ import {
 
 type ParsedArgs = {
   directory?: string;
+  target?: DeployTarget;
   runtime?: Runtime;
   framework?: Framework;
   modulePath?: string;
@@ -46,6 +50,9 @@ type ParsedArgs = {
   billingAccount?: string;
   quotaProjectId?: string;
   autoDeploy?: boolean;
+  autoUpdate?: boolean;
+  noUpdateCheck?: boolean;
+  noGit?: boolean;
   profile: Profile;
   yes: boolean;
   help: boolean;
@@ -67,7 +74,9 @@ export async function run(argv: string[]) {
       return;
     }
 
-    intro(`${pc.bold("create-svc")} ${pc.dim("backend bootstrap")}`);
+    await maybeCheckForUpdate(args);
+
+    intro(`${pc.bold("create-service")} ${pc.dim("microservice bootstrap")}`);
 
     const config = await resolveConfig(args);
     const targetDir = resolve(process.cwd(), config.directory);
@@ -75,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("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"
     );
@@ -88,6 +99,17 @@ export async function run(argv: string[]) {
     await scaffoldProject(config);
     buildSpinner.stop("Project files generated");
 
+    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();
@@ -96,8 +118,15 @@ 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");
       }
     }
 
@@ -105,18 +134,19 @@ export async function run(argv: string[]) {
     outro(
       [
         `Next: ${pc.cyan(`cd ${config.directory}`)}`,
-        `Local DB: ${pc.cyan("docker compose up -d")}`,
+        `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")}`,
-        `Bootstrap: ${pc.cyan(isBun ? "bun run bootstrap" : "make bootstrap")}`,
-        `Deploy: ${pc.cyan(isBun ? "bun run deploy" : "make deploy")}`,
+        `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}`)}`,
-      ].join("\n")
+      ].filter(Boolean).join("\n")
     );
   } catch (error) {
     handleCliError(error);
@@ -160,6 +190,21 @@ export 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;
@@ -170,6 +215,16 @@ export 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;
@@ -260,11 +315,6 @@ export function parseArgs(argv: string[]): ParsedArgs {
       continue;
     }
 
-    if (token === "--bootstrap") {
-      parsed.autoDeploy = true;
-      continue;
-    }
-
     if (token === "--no-auto-deploy") {
       parsed.autoDeploy = false;
       continue;
@@ -276,6 +326,69 @@ 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 serviceName = args.yes
@@ -287,14 +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 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 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({
@@ -315,6 +431,7 @@ export async function resolveConfig(args: ParsedArgs): Promise<ScaffoldConfig> {
     directory,
     serviceName,
     modulePath,
+    target,
     runtime,
     framework,
     profile: args.profile,
@@ -325,6 +442,7 @@ export async function resolveConfig(args: ParsedArgs): Promise<ScaffoldConfig> {
     billingAccount,
     quotaProjectId: args.quotaProjectId ?? QUOTA_PROJECT_DEFAULT,
     autoDeploy,
+    git,
     neonDatabaseName: defaults.neonDatabaseName,
     apiHostname: defaults.apiHostname,
     generatorRoot: resolve(dirname(fileURLToPath(import.meta.url)), ".."),
@@ -344,22 +462,55 @@ async function waitForDiscovery(discoveryPromise: Promise<DiscoveryState>) {
   }
 }
 
-async function resolveRuntime(args: ParsedArgs): Promise<Runtime> {
+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 (args.yes) {
+  if (target === "workers") {
     return "bun";
   }
 
+  if (args.yes) {
+    return "go";
+  }
+
   const value = await select({
     message: "Runtime",
-    initialValue: "bun",
-    options: [
-      { value: "bun", label: "Bun", hint: "Default" },
-      { value: "go", label: "Go" },
-    ],
+    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)) {
@@ -370,17 +521,17 @@ async function resolveRuntime(args: ParsedArgs): Promise<Runtime> {
   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.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({
@@ -639,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) {
@@ -665,10 +827,11 @@ export function validateServiceNameInput(rawValue: string, directoryOverride?: s
 function printHelp() {
   log.message(`
 Usage:
-  bun run index.ts [directory] [options]
+  create-service [service_id] [options]
 
 Options:
-  --profile <microservice>        Compatibility no-op; create-svc only generates microservices
+  --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
@@ -677,9 +840,11 @@ Options:
   --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
+  --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
 `);

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());
+  }
+}

package/src/git-bootstrap.ts

@@ -0,0 +1,110 @@
+import { existsSync } from "node:fs";
+import { dirname } from "node:path";
+
+export type GitBootstrapConfig = {
+  enabled: boolean;
+  owner: string;
+  repository: string;
+};
+
+export type GitBootstrapResult =
+  | { status: "disabled" }
+  | { status: "skipped-existing-worktree"; root: string }
+  | { status: "created"; url: string };
+
+export function buildGitBootstrapConfig(serviceName: string, noGit: boolean | undefined): GitBootstrapConfig {
+  return {
+    enabled: !noGit,
+    owner: "anmho",
+    repository: serviceName,
+  };
+}
+
+export async function bootstrapGitHubRepository(targetDir: string, config: GitBootstrapConfig): Promise<GitBootstrapResult> {
+  if (!config.enabled) {
+    return { status: "disabled" };
+  }
+
+  const existingRoot = findExistingGitWorktree(targetDir);
+  if (existingRoot) {
+    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", "init", "-b", "main"], targetDir);
+  run(["git", "add", "."], targetDir);
+
+  if (hasStagedChanges(targetDir)) {
+    run(["git", "commit", "-m", "Initial commit"], targetDir);
+  }
+
+  const repository = `${config.owner}/${config.repository}`;
+  run(["gh", "repo", "create", repository, "--private", "--source", ".", "--remote", "origin", "--push"], targetDir);
+
+  return {
+    status: "created",
+    url: `https://github.com/${repository}`,
+  };
+}
+
+export function commitAndPushGeneratedArtifacts(targetDir: string, message: string) {
+  run(["git", "add", "."], targetDir);
+  if (!hasStagedChanges(targetDir)) {
+    return { committed: false };
+  }
+  run(["git", "commit", "-m", message], targetDir);
+  run(["git", "push"], targetDir);
+  return { committed: true };
+}
+
+export function findExistingGitWorktree(targetDir: string) {
+  const cwd = existingPath(targetDir);
+  const result = Bun.spawnSync(["git", "-C", cwd, "rev-parse", "--show-toplevel"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (result.exitCode !== 0) {
+    return undefined;
+  }
+  return result.stdout.toString().trim() || undefined;
+}
+
+function existingPath(path: string): string {
+  if (existsSync(path)) {
+    return path;
+  }
+
+  const parent = dirname(path);
+  if (parent === path) {
+    return path;
+  }
+
+  return existingPath(parent);
+}
+
+function hasStagedChanges(cwd: string) {
+  const result = Bun.spawnSync(["git", "diff", "--cached", "--quiet"], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  return result.exitCode === 1;
+}
+
+function run(command: string[], cwd: string, message?: string) {
+  const result = Bun.spawnSync(command, {
+    cwd,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "pipe",
+  });
+  if (result.exitCode === 0) {
+    return;
+  }
+
+  const detail = result.stderr.toString().trim();
+  throw new Error([message, `Command failed: ${command.join(" ")}`, detail].filter(Boolean).join("\n"));
+}

package/src/naming.test.ts

@@ -3,6 +3,7 @@ import { buildGcpProjectOptions, compactDatabaseName, compactIdentifier, deriveD
 
 test("deriveDefaults uses the service name for project, repo, and database naming", () => {
   expect(deriveDefaults("edge-api")).toEqual({
+    serviceId: "edge-api",
     serviceName: "edge-api",
     projectName: "edge-api",
     projectId: "anmho-edge-api",

package/src/naming.ts

@@ -1,6 +1,10 @@
 export const BILLING_ACCOUNT_DEFAULT = "billingAccounts/01BD2E-3A6949-8F4C84";
 export const QUOTA_PROJECT_DEFAULT = "anmho-infra-prod";
 
+export const DEPLOY_TARGETS = ["cloudrun", "workers"] as const;
+
+export type DeployTarget = (typeof DEPLOY_TARGETS)[number];
+
 export const FRAMEWORKS_BY_RUNTIME = {
   go: ["chi", "connectrpc"],
   bun: ["hono", "connectrpc"],
@@ -10,6 +14,24 @@ export type Runtime = keyof typeof FRAMEWORKS_BY_RUNTIME;
 export type Framework = (typeof FRAMEWORKS_BY_RUNTIME)[Runtime][number];
 export type GcpProjectMode = "create_new" | "use_existing";
 
+export function parseDeployTarget(value: string): DeployTarget {
+  if (DEPLOY_TARGETS.includes(value as DeployTarget)) {
+    return value as DeployTarget;
+  }
+
+  throw new Error(`Unknown target: ${value}`);
+}
+
+export function frameworksForTargetRuntime(target: DeployTarget, runtime: Runtime): readonly Framework[] {
+  if (target === "workers") {
+    if (runtime === "bun") {
+      return ["hono"];
+    }
+    return [];
+  }
+  return FRAMEWORKS_BY_RUNTIME[runtime];
+}
+
 export function slugify(value: string, maxLength = 63) {
   return value
     .trim()
@@ -64,6 +86,7 @@ export function deriveDefaults(serviceName: string) {
   const normalizedServiceName = slugify(serviceName) || "my-service";
 
   return {
+    serviceId: normalizedServiceName,
     serviceName: normalizedServiceName,
     projectName: normalizedServiceName,
     projectId: compactIdentifier(`anmho-${normalizedServiceName}`, 30),

package/src/post-scaffold.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from "bun:test";
+import { buildPostScaffoldCommands } from "./post-scaffold";
+
+describe("buildPostScaffoldCommands", () => {
+  test("runs create and deploy for HTTP services", () => {
+    expect(buildPostScaffoldCommands({ framework: "hono" })).toEqual([
+      { command: "bun", args: ["run", "service", "--", "create"] },
+      { command: "bun", args: ["run", "service", "--", "deploy"] },
+    ]);
+  });
+
+  test("builds SDK artifacts before create and deploy for ConnectRPC services", () => {
+    expect(buildPostScaffoldCommands({ framework: "connectrpc" })).toEqual([
+      { command: "bun", args: ["run", "service", "--", "sdk", "build"] },
+      { command: "bun", args: ["run", "service", "--", "create"] },
+      { command: "bun", args: ["run", "service", "--", "deploy"] },
+    ]);
+  });
+});

package/src/post-scaffold.ts

@@ -12,21 +12,34 @@ type CommandResult = {
   stderr: string;
 };
 
+type PostScaffoldCommand = {
+  command: string;
+  args: string[];
+};
+
 const decoder = new TextDecoder();
 const encoder = new TextEncoder();
 
 export async function runPostScaffoldFlow(config: ScaffoldConfig, cwd: string) {
   if (config.autoDeploy) {
     installProjectDependencies(cwd);
-    const command = config.runtime === "bun" ? "bun" : "make";
-    run(command, config.runtime === "bun" ? ["run", "bootstrap"] : ["bootstrap"], { cwd });
-    run(command, config.runtime === "bun" ? ["run", "deploy"] : ["deploy"], { cwd });
-    return { message: "Dependencies installed and first deploy started" };
+    for (const command of buildPostScaffoldCommands(config)) {
+      run(command.command, command.args, { cwd });
+    }
+    return { message: "Dependencies installed, service created, and service deployed" };
   }
 
   return { message: "Backend package generated" };
 }
 
+export function buildPostScaffoldCommands(config: Pick<ScaffoldConfig, "framework">): PostScaffoldCommand[] {
+  return [
+    ...(config.framework === "connectrpc" ? [{ command: "bun", args: ["run", "service", "--", "sdk", "build"] }] : []),
+    { command: "bun", args: ["run", "service", "--", "create"] },
+    { command: "bun", args: ["run", "service", "--", "deploy"] },
+  ];
+}
+
 function installProjectDependencies(cwd: string) {
   requireCommand("bun");
   run("bun", ["install"], { cwd });

package/src/profiles.ts

@@ -9,17 +9,14 @@ export function parseProfile(value: string): Profile {
 
   if (value === "app") {
     throw new Error(
-      [
-        "The app profile moved out of create-svc.",
-        "Use the private GitHub template repos anmho/create-app-consumer or anmho/create-app-saas instead.",
-      ].join(" ")
+      "The app profile has moved out of create-service. Use the private create-app template repositories instead."
     );
   }
 
   throw new Error(`Unknown profile: ${value}`);
 }
 
-export function exampleForProfile(profile: Profile) {
+export function exampleForProfile(_profile: Profile) {
   return {
     kind: "microservice",
     domain: "waitlist",