create-svc 0.1.75 → 0.1.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-svc",
-  "version": "0.1.75",
+  "version": "0.1.77",
   "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

@@ -300,6 +300,21 @@ async function runDoctor() {
       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}`;
+    });
   }
 
   const output = results.map(formatDoctorResult).join("\n");

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

@@ -30,6 +30,43 @@ describe("local dev cleanup", () => {
     expect(await Bun.file(join(root, ".service", "local-dev.pid")).exists()).toBe(false);
   });
 
+  test("stops service-owned listeners when the pid file is missing", async () => {
+    if (!Bun.which("lsof")) {
+      return;
+    }
+
+    const root = await tempRoot();
+    const port = await reservePort();
+    const child = Bun.spawn(
+      [
+        "bun",
+        "-e",
+        "Bun.serve({ port: Number(Bun.env.PORT), fetch() { return new Response('ok'); } }); setInterval(() => {}, 1000);",
+      ],
+      {
+        cwd: root,
+        env: { ...process.env, PORT: String(port) },
+        stdout: "pipe",
+        stderr: "pipe",
+      },
+    );
+    if (!child.pid) {
+      throw new Error("spawned local dev process has no pid");
+    }
+
+    try {
+      await waitForServer(port);
+
+      const result = await stopLocalDev({ root, dockerCompose: false, ports: [port] });
+
+      expect(result).toContain(`Stopped local dev process ${child.pid} on port ${port}`);
+      await waitForListenerStop(port, child.pid);
+    } finally {
+      child.kill("SIGKILL");
+      await child.exited.catch(() => undefined);
+    }
+  }, 10_000);
+
   test("plans Docker Compose cleanup when compose exists", async () => {
     const root = await tempRoot();
     await Bun.write(join(root, "docker-compose.yml"), "services: {}\n");
@@ -45,3 +82,59 @@ async function tempRoot() {
   roots.push(root);
   return root;
 }
+
+async function reservePort() {
+  const server = Bun.serve({ port: 0, fetch: () => new Response("reserved") });
+  const port = server.port;
+  if (!port) {
+    throw new Error("failed to reserve a local port");
+  }
+  await server.stop();
+  return port;
+}
+
+async function waitForServer(port: number) {
+  const deadline = Date.now() + 5_000;
+  while (Date.now() < deadline) {
+    if (await isReachable(port)) {
+      return;
+    }
+    await Bun.sleep(50);
+  }
+  throw new Error(`server on port ${port} did not start`);
+}
+
+async function waitForListenerStop(port: number, pid: number) {
+  const deadline = Date.now() + 5_000;
+  while (Date.now() < deadline) {
+    if (!listenerHasPid(port, pid)) {
+      return;
+    }
+    await Bun.sleep(50);
+  }
+  throw new Error(`process ${pid} on port ${port} did not stop listening`);
+}
+
+async function isReachable(port: number) {
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}`, { signal: AbortSignal.timeout(250) });
+    await response.text();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function listenerHasPid(port: number, pid: number) {
+  const result = Bun.spawnSync(["lsof", "-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-Fp"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (!result.success || !result.stdout) {
+    return false;
+  }
+  return new TextDecoder()
+    .decode(result.stdout)
+    .split("\n")
+    .includes(`p${pid}`);
+}

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

@@ -1,36 +1,49 @@
 import { rm } from "node:fs/promises";
+import { realpathSync } from "node:fs";
 import { join } from "node:path";
 
 type LocalDevOptions = {
   root?: string;
   dockerCompose?: boolean;
   removeVolumes?: boolean;
+  ports?: number[];
 };
 
 export type LocalDevCleanupPlan = {
   pidFile: string;
   hasPidFile: boolean;
   pid?: number;
+  portProcesses: PortProcess[];
   hasDockerCompose: boolean;
   resources: string[];
   skipped: string[];
 };
 
+type PortProcess = {
+  pid: number;
+  port: number;
+};
+
 const decoder = new TextDecoder();
+const defaultLocalDevPorts = [8080, 3000];
 
 export async function buildLocalDevCleanupPlan(options: LocalDevOptions = {}): Promise<LocalDevCleanupPlan> {
   const root = options.root ?? defaultServiceRoot();
   const pidFile = join(root, ".service", "local-dev.pid");
   const hasPidFile = await Bun.file(pidFile).exists();
   const pid = hasPidFile ? parsePid(await Bun.file(pidFile).text()) : undefined;
+  const ports = options.ports ?? defaultLocalDevPorts;
+  const portProcesses = findServicePortProcesses(root, ports, pid);
   const hasDockerCompose = Boolean(options.dockerCompose) && (await Bun.file(join(root, "docker-compose.yml")).exists());
   const resources: string[] = [];
   const skipped: string[] = [];
 
   if (hasPidFile) {
     resources.push(`Local dev process from ${pidFile}`);
+  } else if (portProcesses.length > 0) {
+    resources.push(formatPortProcesses(portProcesses));
   } else {
-    skipped.push("Local dev process: no .service/local-dev.pid");
+    skipped.push(`Local dev process: no .service/local-dev.pid or service-owned listener on ${ports.join(", ")}`);
   }
 
   if (hasDockerCompose) {
@@ -43,6 +56,7 @@ export async function buildLocalDevCleanupPlan(options: LocalDevOptions = {}): P
     pidFile,
     hasPidFile,
     pid,
+    portProcesses,
     hasDockerCompose,
     resources,
     skipped,
@@ -62,7 +76,12 @@ export async function stopLocalDev(options: LocalDevOptions = {}) {
     }
     await rm(plan.pidFile, { force: true });
   } else {
-    messages.push("No local dev pid file found");
+    const stopped = stopPortProcesses(plan.portProcesses);
+    messages.push(
+      stopped.length > 0
+        ? `Stopped ${formatPortProcesses(stopped)}`
+        : "No local dev pid file found and no service-owned local dev process was listening",
+    );
   }
 
   if (plan.hasDockerCompose) {
@@ -84,12 +103,16 @@ function parsePid(raw: string) {
 
 function stopPid(pid: number) {
   const wasRunning = isRunning(pid);
+  if (!wasRunning) {
+    return false;
+  }
   tryKill(-pid, "SIGTERM") || tryKill(pid, "SIGTERM");
-  Bun.sleepSync(1_000);
+  waitForExit(pid, 1_000);
   if (isRunning(pid)) {
     tryKill(-pid, "SIGKILL") || tryKill(pid, "SIGKILL");
+    waitForExit(pid, 1_000);
   }
-  return wasRunning;
+  return !isRunning(pid);
 }
 
 function isRunning(pid: number) {
@@ -110,6 +133,105 @@ function tryKill(pid: number, signal: NodeJS.Signals) {
   }
 }
 
+function waitForExit(pid: number, timeoutMs: number) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isRunning(pid)) {
+      return;
+    }
+    Bun.sleepSync(50);
+  }
+}
+
+function findServicePortProcesses(root: string, ports: number[], pidFromFile?: number): PortProcess[] {
+  if (!Bun.which("lsof")) {
+    return [];
+  }
+
+  const resolvedRoot = realpath(root);
+  const rootWithSlash = resolvedRoot.endsWith("/") ? resolvedRoot : `${resolvedRoot}/`;
+  const seen = new Set<string>();
+  const processes: PortProcess[] = [];
+  for (const port of ports) {
+    for (const pid of listeningPids(port)) {
+      if (pid === pidFromFile) {
+        continue;
+      }
+      const key = `${pid}:${port}`;
+      if (seen.has(key)) {
+        continue;
+      }
+      const cwd = processCwd(pid);
+      if (cwd && (cwd === resolvedRoot || cwd.startsWith(rootWithSlash))) {
+        processes.push({ pid, port });
+        seen.add(key);
+      }
+    }
+  }
+  return processes;
+}
+
+function realpath(path: string) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+
+function listeningPids(port: number) {
+  const result = Bun.spawnSync(["lsof", "-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-Fp"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (!result.success || !result.stdout) {
+    return [];
+  }
+  return decoder
+    .decode(result.stdout)
+    .split("\n")
+    .map((line) => (line.startsWith("p") ? Number.parseInt(line.slice(1), 10) : undefined))
+    .filter((pid): pid is number => Boolean(pid && Number.isFinite(pid)));
+}
+
+function processCwd(pid: number) {
+  if (process.platform === "linux") {
+    const procCwd = realpath(`/proc/${pid}/cwd`);
+    if (procCwd !== `/proc/${pid}/cwd`) {
+      return procCwd;
+    }
+  }
+
+  const result = Bun.spawnSync(["lsof", "-a", "-p", String(pid), "-d", "cwd", "-Fn"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (!result.success || !result.stdout) {
+    return undefined;
+  }
+  return decoder
+    .decode(result.stdout)
+    .split("\n")
+    .find((line) => line.startsWith("n"))
+    ?.slice(1);
+}
+
+function stopPortProcesses(processes: PortProcess[]) {
+  const stopped: PortProcess[] = [];
+  for (const portProcess of processes) {
+    if (stopPid(portProcess.pid) || !listeningPids(portProcess.port).includes(portProcess.pid)) {
+      stopped.push(portProcess);
+    }
+  }
+  return stopped;
+}
+
+function formatPortProcesses(processes: PortProcess[]) {
+  return processes
+    .map((portProcess) => `local dev process ${portProcess.pid} on port ${portProcess.port}`)
+    .join(", ");
+}
+
 function runDockerComposeDown(root: string, removeVolumes: boolean) {
   if (!Bun.which("docker")) {
     return "Docker is not installed; Docker Compose cleanup skipped";

package/src/service.test.ts

@@ -7,6 +7,7 @@ import {
   formatOutsideServiceCommandError,
   generatedDependenciesInstalled,
   generatedServiceCommandHelp,
+  createSvcVersion,
   normalizeScaffoldArgs,
 } from "./service";
 
@@ -21,6 +22,11 @@ test("normalizeScaffoldArgs maps service help to generator help outside a servic
   expect(normalizeScaffoldArgs(["help", "--verbose"])).toEqual(["--help", "--verbose"]);
 });
 
+test("createSvcVersion reports the package version", async () => {
+  const packageJson = await Bun.file(new URL("../package.json", import.meta.url)).json();
+  expect(createSvcVersion()).toBe(packageJson.version);
+});
+
 test("formatOutsideServiceCommandError rejects repo-local commands outside generated services", () => {
   expect(formatOutsideServiceCommandError("destroy")).toContain("service destroy must be run inside a generated service repo");
   expect(formatOutsideServiceCommandError("deploy")).toContain("No service.jsonc was found");

package/src/service.ts

@@ -1,4 +1,4 @@
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { formatScaffoldHelp, run as runScaffoldCli } from "./cli";
 import { parseJsonc } from "./jsonc";
@@ -19,6 +19,11 @@ const GENERATED_SERVICE_COMMANDS = new Set([
 ]);
 
 export async function runServiceCommand(argv: string[], cwd = process.cwd()) {
+  if (isVersionCommand(argv)) {
+    console.log(createSvcVersion());
+    return;
+  }
+
   const serviceRoot = findGeneratedServiceRoot(cwd);
   if (serviceRoot) {
     await delegateToGeneratedService(serviceRoot, argv);
@@ -40,6 +45,15 @@ export async function runServiceCommand(argv: string[], cwd = process.cwd()) {
   process.exit(1);
 }
 
+function isVersionCommand(argv: string[]) {
+  return argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v" || argv[0] === "version");
+}
+
+export function createSvcVersion() {
+  const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")) as { version?: string };
+  return packageJson.version || "unknown";
+}
+
 export function normalizeScaffoldArgs(argv: string[]) {
   const [command, ...rest] = argv;
   if (command && SCAFFOLD_COMMANDS.has(command)) {