create-svc 0.1.81 → 0.1.83

package/package.json

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

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

@@ -1,14 +1,14 @@
 #!/usr/bin/env bun
 
-import { mkdir, readdir, stat } from "node:fs/promises";
+import { stat } from "node:fs/promises";
 import { ensureAuthClient, ensureAuthResourceServer, runAuthCommand, runAuthDoctor } from "../authctl";
+import { recordConnectSdkDoctorChecks } from "../connect-sdk";
 import { stopLocalDev } from "../local-dev";
 import { bootstrap, prepareGcpProject } from "./bootstrap";
 import { cleanup } from "./cleanup";
 import { deploy } from "./deploy";
 import { observabilityBootstrap } from "./observability";
 import { config } from "./config";
-import { formatSdkModeDetail, type SdkState } from "./sdk-state";
 import {
   accessSecretVersion,
   assertProductionDomainAvailable,
@@ -17,7 +17,6 @@ import {
   formatError,
   gcloud,
   ensureProductionDomainMapping,
-  readVaultField,
   requireCommand,
   requireGcloudAuth,
   resolveDeploymentTarget,
@@ -115,11 +114,6 @@ export async function main(argv = Bun.argv.slice(2)) {
     return;
   }
 
-  if (command === "sdk") {
-    await runMain("SDK", () => runSdk(rest));
-    return;
-  }
-
   throw new Error(`Unknown command: ${command}\n\n${formatHelp()}`);
 }
 
@@ -276,46 +270,7 @@ async function runDoctor() {
     return "Temporal worker config present";
   });
 
-  if ((config.framework as string) === "connectrpc") {
-    await record(results, "ConnectRPC proto", "fail", async () => {
-      if (!(await Bun.file("./buf.yaml").exists())) {
-        throw new Error("missing buf.yaml");
-      }
-      const protoFiles = await findFiles("./protos", ".proto");
-      if (protoFiles.length === 0) {
-        throw new Error("missing ConnectRPC proto");
-      }
-      return `${protoFiles.length} proto file(s) present`;
-    });
-    await record(results, "Buf CLI", "warn", () => checkCommand("buf"));
-    await record(results, "generated SDK artifacts", "warn", async () => {
-      const artifacts = await findGeneratedSdkArtifacts();
-      if (artifacts.length === 0) {
-        throw new Error("generated SDK artifacts are missing; run service sdk build");
-      }
-      return "local generated artifacts present";
-    });
-    await record(results, "SDK mode", "warn", async () => {
-      const text = await Bun.file(".service/sdk.json").text();
-      const state = JSON.parse(text) as SdkState;
-      return formatSdkModeDetail(state, bufModule());
-    });
-    await record(results, "SDK remote publish", "warn", async () => {
-      const text = await Bun.file(".service/sdk.json").text();
-      const state = JSON.parse(text) as SdkState;
-      const module = state.module || bufModule();
-      if (state.mode !== "remote") {
-        throw new Error(`SDK is in ${state.mode} mode; run service sdk publish to publish ${module}`);
-      }
-      const authEnv = resolveBufAuthEnv();
-      run("buf", ["registry", "module", "info", module], { env: authEnv });
-      const published = resolvePublishedSdk(authEnv);
-      if (state.remote?.commit && published.commit !== state.remote.commit) {
-        return `remote module readable; latest ${published.commit}, recorded ${state.remote.commit}`;
-      }
-      return `remote module readable at ${module}@${published.commit}`;
-    });
-  }
+  await recordConnectSdkDoctorChecks((name, failureStatus, check) => record(results, name, failureStatus, check));
 
   const output = results.map(formatDoctorResult).join("\n");
   const failures = results.filter((result) => result.status === "fail");
@@ -355,173 +310,6 @@ function formatDoctorResult(result: { name: string; status: "pass" | "warn" | "f
   return `[${marker}] ${result.name}: ${result.detail}`;
 }
 
-async function runSdk(args: string[]) {
-  if ((config.framework as string) !== "connectrpc") {
-    throw new Error("SDK commands are only available for ConnectRPC services");
-  }
-
-  const [subcommand] = args;
-  if (subcommand === "publish") {
-    requireCommand("buf");
-    const authEnv = resolveBufAuthEnv();
-    ensureBufModule(authEnv);
-    run("buf", ["push"], { env: authEnv });
-    const published = resolvePublishedSdk(authEnv);
-    await writeSdkMode("remote", published);
-    return `Schema pushed to Buf Schema Registry and recorded for consumers: ${published.commit}`;
-  }
-
-  if (subcommand === "build") {
-    if (config.runtime === "bun") {
-      run("bun", ["run", "gen"]);
-    } else {
-      run("make", ["gen"]);
-    }
-    await writeSdkMode("local");
-    return "Local SDK artifacts generated and recorded";
-  }
-
-  if (subcommand === "use-local") {
-    await assertLocalSdkArtifacts();
-    await writeSdkMode("local");
-    return "Local SDK artifacts recorded";
-  }
-
-  if (subcommand === "use-remote") {
-    requireCommand("buf");
-    const authEnv = resolveBufAuthEnv();
-    const published = resolvePublishedSdk(authEnv);
-    await writeSdkMode("remote", published);
-    return `Remote Buf SDK recorded for consumers: ${bufModule()}@${published.commit}`;
-  }
-
-  throw new Error("Usage: service sdk <build|publish|use-local|use-remote>");
-}
-
-async function assertLocalSdkArtifacts() {
-  const artifacts = await findGeneratedSdkArtifacts();
-  if (artifacts.length === 0) {
-    throw new Error("Local SDK artifacts are missing. Run `service sdk build` first.");
-  }
-}
-
-type PublishedSdk = {
-  commit: string;
-  digest?: string;
-  createTime?: string;
-};
-
-function resolvePublishedSdk(authEnv: Record<string, string> = {}): PublishedSdk {
-  const module = bufModule();
-  const result = run("buf", ["registry", "module", "commit", "list", module, "--format", "json", "--page-size", "1"], { env: authEnv });
-  const parsed = JSON.parse(result.stdout) as {
-    commits?: Array<Record<string, unknown>>;
-    commit?: Record<string, unknown>;
-  };
-  const commit = parsed.commits?.[0] ?? parsed.commit;
-  if (!commit) {
-    throw new Error(`Could not resolve the published Buf commit for ${module}`);
-  }
-  const name = stringField(commit, "name") ?? stringField(commit, "commit") ?? stringField(commit, "id");
-  if (!name) {
-    throw new Error(`Buf commit response for ${module} did not include a commit identifier`);
-  }
-  return {
-    commit: name.includes(":") ? name.slice(name.lastIndexOf(":") + 1) : name,
-    digest: stringField(commit, "digest"),
-    createTime: stringField(commit, "create_time") ?? stringField(commit, "createTime"),
-  };
-}
-
-function stringField(source: Record<string, unknown>, key: string) {
-  const value = source[key];
-  return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-
-async function writeSdkMode(mode: "local" | "remote", published?: PublishedSdk) {
-  await mkdir(".service", { recursive: true });
-  const localPath = await resolveLocalSdkPath();
-  await Bun.write(
-    ".service/sdk.json",
-    `${JSON.stringify(
-      {
-        mode,
-        module: bufModule(),
-        localPath,
-        ...(published
-          ? {
-              remote: {
-                commit: published.commit,
-                digest: published.digest,
-                createTime: published.createTime,
-              },
-            }
-          : {}),
-        updatedAt: new Date().toISOString(),
-      },
-      null,
-      2
-    )}\n`
-  );
-}
-
-function bufModule() {
-  return config.buf.module || `buf.build/anmho-services/${config.serviceName}`;
-}
-
-function ensureBufModule(authEnv: Record<string, string>) {
-  const module = bufModule();
-  const existing = run("buf", ["registry", "module", "info", module], { env: authEnv, allowFailure: true });
-  if (existing.success) {
-    return;
-  }
-  run("buf", ["registry", "module", "create", module, "--visibility", "private"], { env: authEnv });
-}
-
-function resolveBufAuthEnv(): Record<string, string> {
-  const token =
-    process.env.BUF_TOKEN?.trim() ||
-    readVaultField(config.buf.vaultMount, config.buf.vaultPath, ["BUF_TOKEN", "buf.api_token", "buf_token", "api_token", "token"]);
-  if (!token) {
-    return {};
-  }
-  return { BUF_TOKEN: token };
-}
-
-async function resolveLocalSdkPath() {
-  const artifacts = await findGeneratedSdkArtifacts();
-  if (artifacts.length === 0) {
-    return config.runtime === "bun" ? "./gen/protos" : "./gen";
-  }
-  const artifact = artifacts[0] || "./gen";
-  return artifact.split("/").slice(0, -1).join("/") || "./gen";
-}
-
-async function findGeneratedSdkArtifacts() {
-  const suffixes = config.runtime === "bun" ? ["_pb.ts", "_pb.js"] : [".pb.go"];
-  const files = await findFiles("./gen");
-  return files.filter((file) => suffixes.some((suffix) => file.endsWith(suffix)));
-}
-
-async function findFiles(root: string, suffix = ""): Promise<string[]> {
-  let entries;
-  try {
-    entries = await readdir(root, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const files: string[] = [];
-  for (const entry of entries) {
-    const path = `${root}/${entry.name}`;
-    if (entry.isDirectory()) {
-      files.push(...(await findFiles(path, suffix)));
-    } else if (!suffix || path.endsWith(suffix)) {
-      files.push(path);
-    }
-  }
-  return files;
-}
-
 async function directoryExists(path: string) {
   try {
     return (await stat(path)).isDirectory();

package/src/service-runtime/cloudrun/deploy-args.ts

@@ -110,3 +110,7 @@ export function migrationCommandForRuntime(runtime: string): RuntimeMigrationCom
 
   throw new Error(`migrate is not available for ${runtime}`);
 }
+
+export function cloudRunServiceNamesForDestroy(serviceName: string) {
+  return [serviceName, `${serviceName}-worker`];
+}

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

@@ -24,7 +24,7 @@ import {
   writeRenderedManifest,
   writeRenderedWorkerManifest,
 } from "./lib";
-import { migrationCommandForRuntime } from "./deploy-args";
+import { cloudRunServiceNamesForDestroy, migrationCommandForRuntime } from "./deploy-args";
 
 type DeployOptions = {
   bootstrapResult?: BootstrapResult;
@@ -49,7 +49,9 @@ export async function deploy(args = Bun.argv.slice(2), deployOptions: DeployOpti
       throw new Error("Refusing to destroy the main environment");
     }
 
-    await runStep(`Deleting Cloud Run service ${target.serviceName}`, () => deleteService(target.serviceName));
+    for (const serviceName of cloudRunServiceNamesForDestroy(target.serviceName)) {
+      await runStep(`Deleting Cloud Run service ${serviceName}`, () => deleteService(serviceName));
+    }
     await runStep(`Deleting Neon branch ${target.branchName}`, async () => {
       const branches = await listBranches(neon.projectId);
       const branch = branches.find((candidate: { name: string }) => candidate.name === target.branchName);

package/src/service-runtime/cloudrun/lib.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, expect, test } from "bun:test";
-import { localDockerBuildArgs, migrationCommandForRuntime, parseDeployArgs } from "./deploy-args";
+import { cloudRunServiceNamesForDestroy, localDockerBuildArgs, migrationCommandForRuntime, parseDeployArgs } from "./deploy-args";
 
 const originalBuild = process.env.SERVICE_BUILD;
 const originalBuildStrategy = process.env.SERVICE_BUILD_STRATEGY;
@@ -49,3 +49,7 @@ test("migrationCommandForRuntime uses generated migration tooling", () => {
     args: ["migrate", "apply", "--env", "local"],
   });
 });
+
+test("cloudRunServiceNamesForDestroy includes api and worker services", () => {
+  expect(cloudRunServiceNamesForDestroy("omnichannel-pr-6")).toEqual(["omnichannel-pr-6", "omnichannel-pr-6-worker"]);
+});

package/src/service-runtime/cloudrun/sdk.test.ts

@@ -3,7 +3,7 @@ import { chmod, mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { scaffoldProject, type ScaffoldConfig } from "../../scaffold";
-import { formatSdkModeDetail } from "./sdk-state";
+import { formatSdkModeDetail } from "../connect-sdk-state";
 
 function baseConfig(directory: string): ScaffoldConfig {
   return {

package/src/service-runtime/connect-sdk.ts

@@ -0,0 +1,293 @@
+import { mkdir, readdir } from "node:fs/promises";
+import { serviceConfig } from "./runtime";
+import { formatSdkModeDetail, type SdkState } from "./connect-sdk-state";
+
+type CommandResult = {
+  success: boolean;
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+};
+
+type PublishedSdk = {
+  commit: string;
+  digest?: string;
+  createTime?: string;
+};
+
+type DoctorRecorder = (
+  name: string,
+  failureStatus: "warn" | "fail",
+  check: () => string | Promise<string>
+) => Promise<void>;
+
+const decoder = new TextDecoder();
+
+export async function runConnectSdk(args: string[]) {
+  if ((serviceConfig.framework as string) !== "connectrpc") {
+    throw new Error("SDK commands are only available for ConnectRPC services");
+  }
+
+  const [subcommand] = args;
+  if (subcommand === "publish") {
+    requireCommand("buf");
+    const authEnv = resolveBufAuthEnv();
+    ensureBufModule(authEnv);
+    run("buf", ["push"], { env: authEnv });
+    const published = resolvePublishedSdk(authEnv);
+    await writeSdkMode("remote", published);
+    return `Schema pushed to Buf Schema Registry and recorded for consumers: ${published.commit}`;
+  }
+
+  if (subcommand === "build") {
+    if (serviceConfig.runtime === "bun") {
+      run("bun", ["run", "gen"]);
+    } else {
+      run("make", ["gen"]);
+    }
+    await writeSdkMode("local");
+    return "Local SDK artifacts generated and recorded";
+  }
+
+  if (subcommand === "use-local") {
+    await assertLocalSdkArtifacts();
+    await writeSdkMode("local");
+    return "Local SDK artifacts recorded";
+  }
+
+  if (subcommand === "use-remote") {
+    requireCommand("buf");
+    const authEnv = resolveBufAuthEnv();
+    const published = resolvePublishedSdk(authEnv);
+    await writeSdkMode("remote", published);
+    return `Remote Buf SDK recorded for consumers: ${bufModule()}@${published.commit}`;
+  }
+
+  throw new Error("Usage: service sdk <build|publish|use-local|use-remote>");
+}
+
+export async function recordConnectSdkDoctorChecks(record: DoctorRecorder) {
+  if ((serviceConfig.framework as string) !== "connectrpc") {
+    return;
+  }
+
+  await record("ConnectRPC proto", "fail", async () => {
+    if (!(await Bun.file("./buf.yaml").exists())) {
+      throw new Error("missing buf.yaml");
+    }
+    const protoFiles = await findFiles("./protos", ".proto");
+    if (protoFiles.length === 0) {
+      throw new Error("missing ConnectRPC proto");
+    }
+    return `${protoFiles.length} proto file(s) present`;
+  });
+  await record("Buf CLI", "warn", () => checkCommand("buf"));
+  await record("generated SDK artifacts", "warn", async () => {
+    const artifacts = await findGeneratedSdkArtifacts();
+    if (artifacts.length === 0) {
+      throw new Error("generated SDK artifacts are missing; run service sdk build");
+    }
+    return "local generated artifacts present";
+  });
+  await record("SDK mode", "warn", async () => {
+    const text = await Bun.file(".service/sdk.json").text();
+    const state = JSON.parse(text) as SdkState;
+    return formatSdkModeDetail(state, bufModule());
+  });
+  await record("SDK remote publish", "warn", async () => {
+    const text = await Bun.file(".service/sdk.json").text();
+    const state = JSON.parse(text) as SdkState;
+    const module = state.module || bufModule();
+    if (state.mode !== "remote") {
+      throw new Error(`SDK is in ${state.mode} mode; run service sdk publish to publish ${module}`);
+    }
+    const authEnv = resolveBufAuthEnv();
+    run("buf", ["registry", "module", "info", module], { env: authEnv });
+    const published = resolvePublishedSdk(authEnv);
+    if (state.remote?.commit && published.commit !== state.remote.commit) {
+      return `remote module readable; latest ${published.commit}, recorded ${state.remote.commit}`;
+    }
+    return `remote module readable at ${module}@${published.commit}`;
+  });
+}
+
+async function assertLocalSdkArtifacts() {
+  const artifacts = await findGeneratedSdkArtifacts();
+  if (artifacts.length === 0) {
+    throw new Error("Local SDK artifacts are missing. Run `service sdk build` first.");
+  }
+}
+
+function resolvePublishedSdk(authEnv: Record<string, string> = {}): PublishedSdk {
+  const module = bufModule();
+  const result = run("buf", ["registry", "module", "commit", "list", module, "--format", "json", "--page-size", "1"], { env: authEnv });
+  const parsed = JSON.parse(result.stdout) as {
+    commits?: Array<Record<string, unknown>>;
+    commit?: Record<string, unknown>;
+  };
+  const commit = parsed.commits?.[0] ?? parsed.commit;
+  if (!commit) {
+    throw new Error(`Could not resolve the published Buf commit for ${module}`);
+  }
+  const name = stringField(commit, "name") ?? stringField(commit, "commit") ?? stringField(commit, "id");
+  if (!name) {
+    throw new Error(`Buf commit response for ${module} did not include a commit identifier`);
+  }
+  return {
+    commit: name.includes(":") ? name.slice(name.lastIndexOf(":") + 1) : name,
+    digest: stringField(commit, "digest"),
+    createTime: stringField(commit, "create_time") ?? stringField(commit, "createTime"),
+  };
+}
+
+function stringField(source: Record<string, unknown>, key: string) {
+  const value = source[key];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+async function writeSdkMode(mode: "local" | "remote", published?: PublishedSdk) {
+  await mkdir(".service", { recursive: true });
+  const localPath = await resolveLocalSdkPath();
+  await Bun.write(
+    ".service/sdk.json",
+    `${JSON.stringify(
+      {
+        mode,
+        module: bufModule(),
+        localPath,
+        ...(published
+          ? {
+              remote: {
+                commit: published.commit,
+                digest: published.digest,
+                createTime: published.createTime,
+              },
+            }
+          : {}),
+        updatedAt: new Date().toISOString(),
+      },
+      null,
+      2
+    )}\n`
+  );
+}
+
+function bufModule() {
+  return serviceConfig.buf?.module || `buf.build/anmho-services/${serviceConfig.service_id}`;
+}
+
+function ensureBufModule(authEnv: Record<string, string>) {
+  const module = bufModule();
+  const existing = run("buf", ["registry", "module", "info", module], { env: authEnv, allowFailure: true });
+  if (existing.success) {
+    return;
+  }
+  run("buf", ["registry", "module", "create", module, "--visibility", "private"], { env: authEnv });
+}
+
+function resolveBufAuthEnv(): Record<string, string> {
+  const vault = serviceConfig.providers?.vault ?? {};
+  const token =
+    process.env.BUF_TOKEN?.trim() ||
+    readVaultField(vault.mount || "secret", vault.buf_path || "prod/providers/buf", [
+      "BUF_TOKEN",
+      "buf.api_token",
+      "buf_token",
+      "api_token",
+      "token",
+    ]);
+  if (!token) {
+    return {};
+  }
+  return { BUF_TOKEN: token };
+}
+
+async function resolveLocalSdkPath() {
+  const artifacts = await findGeneratedSdkArtifacts();
+  if (artifacts.length === 0) {
+    return serviceConfig.runtime === "bun" ? "./gen/protos" : "./gen";
+  }
+  const artifact = artifacts[0] || "./gen";
+  return artifact.split("/").slice(0, -1).join("/") || "./gen";
+}
+
+async function findGeneratedSdkArtifacts() {
+  const suffixes = serviceConfig.runtime === "bun" ? ["_pb.ts", "_pb.js"] : [".pb.go"];
+  const files = await findFiles("./gen");
+  return files.filter((file) => suffixes.some((suffix) => file.endsWith(suffix)));
+}
+
+async function findFiles(root: string, suffix = ""): Promise<string[]> {
+  let entries;
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files: string[] = [];
+  for (const entry of entries) {
+    const path = `${root}/${entry.name}`;
+    if (entry.isDirectory()) {
+      files.push(...(await findFiles(path, suffix)));
+    } else if (!suffix || path.endsWith(suffix)) {
+      files.push(path);
+    }
+  }
+  return files;
+}
+
+function requireCommand(name: string) {
+  if (!Bun.which(name)) {
+    throw new Error(`missing required command: ${name}`);
+  }
+}
+
+function checkCommand(name: string) {
+  const path = Bun.which(name);
+  if (!path) {
+    throw new Error(`${name} is not installed`);
+  }
+  return path;
+}
+
+function run(command: string, args: string[], options: { allowFailure?: boolean; env?: Record<string, string | undefined> } = {}): CommandResult {
+  const result = Bun.spawnSync([command, ...args], {
+    cwd: process.cwd(),
+    env: { ...process.env, ...options.env },
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const commandResult = {
+    success: result.success,
+    stdout: result.stdout ? decoder.decode(result.stdout).trim() : "",
+    stderr: result.stderr ? decoder.decode(result.stderr).trim() : "",
+    exitCode: result.exitCode,
+  };
+  if (!commandResult.success && !options.allowFailure) {
+    throw new Error(`command failed: ${command} ${args.join(" ")}`);
+  }
+  return commandResult;
+}
+
+function readVaultField(mount: string, path: string, fields: string[]) {
+  const vault = Bun.which("vault");
+  if (!vault || !path) {
+    return "";
+  }
+
+  for (const field of fields) {
+    const result = Bun.spawnSync([vault, "kv", "get", `-mount=${mount}`, `-field=${field}`, path], {
+      cwd: process.cwd(),
+      env: process.env,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (result.success && result.stdout) {
+      const value = decoder.decode(result.stdout).trim();
+      if (value) {
+        return value;
+      }
+    }
+  }
+  return "";
+}

package/src/service-runtime/local-dev.test.ts

@@ -56,6 +56,7 @@ describe("local dev cleanup", () => {
 
     try {
       await waitForServer(port);
+      await waitForServiceOwnedListener(root, port, child.pid);
 
       const result = await stopLocalDev({ root, dockerCompose: false, ports: [port] });
 
@@ -115,6 +116,18 @@ async function waitForListenerStop(port: number, pid: number) {
   throw new Error(`process ${pid} on port ${port} did not stop listening`);
 }
 
+async function waitForServiceOwnedListener(root: string, port: number, pid: number) {
+  const deadline = Date.now() + 5_000;
+  while (Date.now() < deadline) {
+    const plan = await buildLocalDevCleanupPlan({ root, dockerCompose: false, ports: [port] });
+    if (plan.portProcesses.some((process) => process.pid === pid && process.port === port)) {
+      return;
+    }
+    await Bun.sleep(50);
+  }
+  throw new Error(`process ${pid} on port ${port} was not detected as service-owned`);
+}
+
 async function isReachable(port: number) {
   try {
     const response = await fetch(`http://127.0.0.1:${port}`, { signal: AbortSignal.timeout(250) });

package/src/service.ts

@@ -159,6 +159,15 @@ async function delegateToGeneratedService(serviceRoot: string, argv: string[]) {
     return;
   }
 
+  if (argv[0] === "sdk") {
+    const { intro, outro } = await import("@clack/prompts");
+    const { runConnectSdk } = await import("./service-runtime/connect-sdk");
+    intro("SDK");
+    const result = await runConnectSdk(argv.slice(1));
+    outro(result);
+    return;
+  }
+
   if (serviceConfig.target === "workers") {
     const { main } = await import("./service-runtime/workers/cli");
     await main(argv);