@nanobpm/urban 0.96.0 → 0.96.1

package/dist/cli.d.ts

@@ -23,4 +23,12 @@ interface Flags {
  */
 export declare function cmdData(f: Flags, readInput?: () => Promise<string>): Promise<number>;
 export declare function main(argv: string[]): Promise<number>;
+/**
+ * Run the CLI as the process entrypoint: `main(argv)`, then drain stdio and exit with its code.
+ * A negative code means a long-running command (`run`, `dev`) owns the process, so it is left
+ * alive. Exported so the `urban` bin (`bin.mjs`) can run the CLI **in-process** via `import()`
+ * instead of spawning a second Node (nano-ide#589): every `urban` command, notably each
+ * gateway `urban data` op, used to pay two Node start-ups.
+ */
+export declare function runCli(argv: string[]): Promise<void>;
 export {};

package/dist/cli.js

@@ -457,24 +457,23 @@ async function flushStdio() {
         return;
     await Promise.all([flushStream(p.stdout), flushStream(p.stderr)]);
 }
-const proc = processGlobal();
-const deno = denoGlobal();
-const importMetaMain = Reflect.get(import.meta, "main");
-const argv1 = proc?.argv?.[1];
-const nodeMain = argv1 ? import.meta.url === pathToFileURL(argv1).href : false;
-if (importMetaMain === true || nodeMain) {
-    // Node passes args via process.argv (slice off exec+script); Deno (run directly)
-    // exposes them on Deno.args. Prefer whichever actually carries args.
-    const fromNode = proc?.argv?.slice(2);
-    const fromDeno = deno?.args;
-    const argv = (fromNode && fromNode.length ? fromNode : fromDeno) ?? fromNode ?? [];
+/**
+ * Run the CLI as the process entrypoint: `main(argv)`, then drain stdio and exit with its code.
+ * A negative code means a long-running command (`run`, `dev`) owns the process, so it is left
+ * alive. Exported so the `urban` bin (`bin.mjs`) can run the CLI **in-process** via `import()`
+ * instead of spawning a second Node (nano-ide#589): every `urban` command, notably each
+ * gateway `urban data` op, used to pay two Node start-ups.
+ */
+export function runCli(argv) {
+    const proc = processGlobal();
+    const deno = denoGlobal();
     const exit = (code) => {
         if (proc?.exit)
             proc.exit(code);
         else if (deno?.exit)
             deno.exit(code);
     };
-    main(argv).then(async (code) => {
+    return main(argv).then(async (code) => {
         if (code >= 0) {
             await flushStdio();
             exit(code);
@@ -485,3 +484,16 @@ if (importMetaMain === true || nodeMain) {
         exit(1);
     });
 }
+const proc = processGlobal();
+const deno = denoGlobal();
+const importMetaMain = Reflect.get(import.meta, "main");
+const argv1 = proc?.argv?.[1];
+const nodeMain = argv1 ? import.meta.url === pathToFileURL(argv1).href : false;
+if (importMetaMain === true || nodeMain) {
+    // Node passes args via process.argv (slice off exec+script); Deno (run directly)
+    // exposes them on Deno.args. Prefer whichever actually carries args.
+    const fromNode = proc?.argv?.slice(2);
+    const fromDeno = deno?.args;
+    const argv = (fromNode && fromNode.length ? fromNode : fromDeno) ?? fromNode ?? [];
+    void runCli(argv);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nanobpm/urban",
-	"version": "0.96.0",
+	"version": "0.96.1",
 	"description": "Urban: build and run code-first apps on Nano — runtime, derivation toolkit, and CLI in one. Author durable processes with @nanobpm/workflow (defineFlow), a typed datasource, forms, triggers and surfaces from a nano.app.json manifest, on Node or Deno.",
 	"license": "Apache-2.0",
 	"type": "module",

package/src/bin.mjs

@@ -3,16 +3,23 @@
 // published as compiled JS + .d.ts because Node cannot strip types for files under
 // node_modules (ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING), so no type-stripping flag
 // is needed here.
+//
+// The CLI is loaded IN-PROCESS (dynamic import + runCli) rather than spawned as a second
+// Node: a spawn doubled the start-up cost of every command, and the gateway runs `urban
+// data` once per data op (nano-ide#589, nano-bpm#1340). dist/cli.js only auto-runs when it
+// is argv[1] itself, so importing it here does not start it twice.
 
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { dirname, join } from "node:path";
 
 const cli = join(dirname(fileURLToPath(import.meta.url)), "..", "dist", "cli.js");
 
-const r = spawnSync(process.execPath, [cli, ...process.argv.slice(2)], { stdio: "inherit" });
-if (r.error) {
-  console.error(String(r.error.message ?? r.error));
+let runCli;
+try {
+  ({ runCli } = await import(pathToFileURL(cli).href));
+} catch (err) {
+  console.error(String(err?.message ?? err));
   process.exit(1);
 }
-process.exit(r.status ?? 1);
+// runCli owns the exit code, stdio flushing and long-running commands (run/dev).
+await runCli(process.argv.slice(2));

package/src/bin.test.ts

@@ -0,0 +1,74 @@
+// The `urban` bin (`bin.mjs`) must run the compiled CLI in the SAME Node process (nano-ide#589):
+// the gateway spawns `urban data` per data op, and the old spawnSync bootstrap paid two Node
+// start-ups for every one. Exercises the real bin against dist/ (CI builds before testing).
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const bin = fileURLToPath(new URL("./bin.mjs", import.meta.url));
+const dist = fileURLToPath(new URL("../dist/cli.js", import.meta.url));
+
+function runBin(
+  args: string[],
+  stdin: string,
+  env: NodeJS.ProcessEnv,
+): Promise<{ stdout: string; code: number | null }> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [bin, ...args], {
+      stdio: ["pipe", "pipe", "inherit"],
+      env: { ...process.env, ...env },
+    });
+    const chunks: Buffer[] = [];
+    child.stdout.on("data", (c: Buffer) => chunks.push(c));
+    child.on("error", reject);
+    child.on("close", (code) => resolve({ stdout: Buffer.concat(chunks).toString("utf8"), code }));
+    child.stdin.end(stdin);
+  });
+}
+
+// `bin.mjs` is the npm bin, so it always runs under Node: skip under Deno (`test:deno`), whose
+// process.execPath is not Node (same as generated-lint.test.ts).
+const runtimeIsNode = !("Deno" in globalThis);
+
+test("bin.mjs runs the CLI in-process: one Node per command, reply + exit code intact", {
+  skip: runtimeIsNode ? false : "Node-only: spawns bin.mjs via process.execPath (Deno's execPath is not Node)",
+}, async (t) => {
+  if (!existsSync(dist)) {
+    t.skip("dist/cli.js not built (run `npm run build`); CI builds before testing");
+    return;
+  }
+  const dir = mkdtempSync(join(tmpdir(), "urban-bin-"));
+  try {
+    // A preload every Node process runs (NODE_OPTIONS is inherited by child Nodes), recording
+    // its pid. The old spawnSync bootstrap would record two.
+    const pids = join(dir, "pids.txt");
+    const preload = join(dir, "preload.mjs");
+    writeFileSync(
+      preload,
+      `import { appendFileSync } from "node:fs";\nappendFileSync(${JSON.stringify(pids)}, process.pid + "\\n");\n`,
+    );
+    const env = { NODE_OPTIONS: `--import=${pathToFileURL(preload).href}` };
+
+    // An unreadable request: `urban data` still answers with a parseable envelope and exits 0.
+    const { stdout, code } = await runBin(["data", "--root", dir], "not json", env);
+    assert.equal(code, 0, `bin exited ${code}, expected 0`);
+    const reply: unknown = JSON.parse(stdout);
+    assert.ok(reply !== null && typeof reply === "object", "reply is not an object");
+    assert.equal(Reflect.get(reply, "ok"), false);
+    assert.match(String(Reflect.get(reply, "error")), /^bad request:/);
+
+    const started = readFileSync(pids, "utf8").trim().split("\n").filter(Boolean);
+    assert.equal(started.length, 1, `expected 1 Node process, got ${started.length}`);
+
+    // A failing command's non-zero exit code still propagates through the bin.
+    const unknown = await runBin(["no-such-command"], "", {});
+    assert.equal(unknown.code, 1);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/cli.ts

@@ -472,22 +472,21 @@ async function flushStdio(): Promise<void> {
   await Promise.all([flushStream(p.stdout), flushStream(p.stderr)]);
 }
 
-const proc = processGlobal();
-const deno = denoGlobal();
-const importMetaMain: unknown = Reflect.get(import.meta, "main");
-const argv1 = proc?.argv?.[1];
-const nodeMain = argv1 ? import.meta.url === pathToFileURL(argv1).href : false;
-if (importMetaMain === true || nodeMain) {
-  // Node passes args via process.argv (slice off exec+script); Deno (run directly)
-  // exposes them on Deno.args. Prefer whichever actually carries args.
-  const fromNode = proc?.argv?.slice(2);
-  const fromDeno = deno?.args;
-  const argv = (fromNode && fromNode.length ? fromNode : fromDeno) ?? fromNode ?? [];
+/**
+ * Run the CLI as the process entrypoint: `main(argv)`, then drain stdio and exit with its code.
+ * A negative code means a long-running command (`run`, `dev`) owns the process, so it is left
+ * alive. Exported so the `urban` bin (`bin.mjs`) can run the CLI **in-process** via `import()`
+ * instead of spawning a second Node (nano-ide#589): every `urban` command, notably each
+ * gateway `urban data` op, used to pay two Node start-ups.
+ */
+export function runCli(argv: string[]): Promise<void> {
+  const proc = processGlobal();
+  const deno = denoGlobal();
   const exit = (code: number) => {
     if (proc?.exit) proc.exit(code);
     else if (deno?.exit) deno.exit(code);
   };
-  main(argv).then(
+  return main(argv).then(
     async (code) => {
       if (code >= 0) {
         await flushStdio();
@@ -501,3 +500,17 @@ if (importMetaMain === true || nodeMain) {
     },
   );
 }
+
+const proc = processGlobal();
+const deno = denoGlobal();
+const importMetaMain: unknown = Reflect.get(import.meta, "main");
+const argv1 = proc?.argv?.[1];
+const nodeMain = argv1 ? import.meta.url === pathToFileURL(argv1).href : false;
+if (importMetaMain === true || nodeMain) {
+  // Node passes args via process.argv (slice off exec+script); Deno (run directly)
+  // exposes them on Deno.args. Prefer whichever actually carries args.
+  const fromNode = proc?.argv?.slice(2);
+  const fromDeno = deno?.args;
+  const argv = (fromNode && fromNode.length ? fromNode : fromDeno) ?? fromNode ?? [];
+  void runCli(argv);
+}