@intentius/chant 0.18.27 → 0.18.28

package/dist/cli/main.d.ts

@@ -4,4 +4,14 @@ import { type ParsedArgs } from "./registry.js";
  * Parse command line arguments
  */
 export declare function parseArgs(args: string[]): ParsedArgs;
+/**
+ * Wait until a writable stream has flushed its buffer. `process.exit()` discards
+ * data still buffered for an async sink (a pipe or file), truncating large output
+ * at the ~64 KB pipe buffer — so `chant graph --format ir` piped into a consumer
+ * loses everything past 64 KB and its JSON won't parse. A TTY writes
+ * synchronously (`writableLength` stays 0), so this is a no-op there. Resolves on
+ * `error`/`close` too, so a reader that closes early (EPIPE) can't hang exit.
+ * Exported for testing.
+ */
+export declare function waitForStreamDrain(stream: NodeJS.WriteStream): Promise<void>;
 //# sourceMappingURL=main.d.ts.map

package/dist/cli/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AAMA,OAAO,EAAmC,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAkB9E;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CA2LpD"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AAMA,OAAO,EAAmC,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAkB9E;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CA2LpD;AAsVD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB5E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.18.27",
+  "version": "0.18.28",
   "description": "Declarative infrastructure-as-code toolkit \u2014 TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

package/src/cli/main.test.ts

@@ -1,5 +1,6 @@
 import { describe, test, expect } from "vitest";
-import { parseArgs } from "./main";
+import { EventEmitter } from "node:events";
+import { parseArgs, waitForStreamDrain } from "./main";
 import { resolveCommand, type CommandDef, type ParsedArgs } from "./registry";
 
 describe("parseArgs", () => {
@@ -416,3 +417,50 @@ describe("parseArgs — run flags", () => {
     expect(result.extraPositional2).toBe("gate-dns");
   });
 });
+
+describe("waitForStreamDrain", () => {
+  // Minimal writable stub — just the surface waitForStreamDrain reads.
+  function fakeStream(len: number): NodeJS.WriteStream & { writableLength: number } {
+    const s = new EventEmitter() as unknown as NodeJS.WriteStream & { writableLength: number };
+    s.writableLength = len;
+    (s as { writableEnded: boolean }).writableEnded = false;
+    (s as { destroyed: boolean }).destroyed = false;
+    return s;
+  }
+
+  test("resolves immediately when nothing is buffered (e.g. a TTY)", async () => {
+    await expect(waitForStreamDrain(fakeStream(0))).resolves.toBeUndefined();
+  });
+
+  test("waits through drains until the buffer is actually empty", async () => {
+    const s = fakeStream(1000);
+    let done = false;
+    const p = waitForStreamDrain(s).then(() => (done = true));
+    await Promise.resolve();
+    expect(done).toBe(false);
+    // A drain while still buffered must NOT resolve (large one-shot write, kernel
+    // took a slice, more remains) — it re-arms.
+    s.emit("drain");
+    await Promise.resolve();
+    expect(done).toBe(false);
+    // Fully flushed now.
+    s.writableLength = 0;
+    s.emit("drain");
+    await p;
+    expect(done).toBe(true);
+  });
+
+  test("resolves on error so a reader that closed early (EPIPE) can't hang exit", async () => {
+    const s = fakeStream(500);
+    const p = waitForStreamDrain(s);
+    s.emit("error", new Error("EPIPE"));
+    await expect(p).resolves.toBeUndefined();
+  });
+
+  test("resolves on close as well", async () => {
+    const s = fakeStream(500);
+    const p = waitForStreamDrain(s);
+    s.emit("close");
+    await expect(p).resolves.toBeUndefined();
+  });
+});

package/src/cli/main.ts

@@ -551,7 +551,48 @@ async function main(): Promise<void> {
   const serializers = plugins.map((p) => p.serializer);
   const ctx = { args, plugins, serializers };
 
-  process.exit(await match.def.handler(ctx));
+  await flushAndExit(await match.def.handler(ctx));
+}
+
+/**
+ * Wait until a writable stream has flushed its buffer. `process.exit()` discards
+ * data still buffered for an async sink (a pipe or file), truncating large output
+ * at the ~64 KB pipe buffer — so `chant graph --format ir` piped into a consumer
+ * loses everything past 64 KB and its JSON won't parse. A TTY writes
+ * synchronously (`writableLength` stays 0), so this is a no-op there. Resolves on
+ * `error`/`close` too, so a reader that closes early (EPIPE) can't hang exit.
+ * Exported for testing.
+ */
+export function waitForStreamDrain(stream: NodeJS.WriteStream): Promise<void> {
+  return new Promise((resolve) => {
+    const tick = (): void => {
+      if (stream.writableLength === 0 || stream.writableEnded || stream.destroyed) {
+        cleanup();
+        resolve();
+        return;
+      }
+      stream.once("drain", tick);
+    };
+    const stop = (): void => {
+      cleanup();
+      resolve();
+    };
+    const cleanup = (): void => {
+      stream.off("drain", tick);
+      stream.off("error", stop);
+      stream.off("close", stop);
+    };
+    stream.once("error", stop);
+    stream.once("close", stop);
+    tick();
+  });
+}
+
+/** Flush stdout+stderr, then exit — so a large piped payload isn't truncated. */
+async function flushAndExit(code: number): Promise<never> {
+  await waitForStreamDrain(process.stdout);
+  await waitForStreamDrain(process.stderr);
+  process.exit(code);
 }
 
 // Only run main when executed directly, not when imported. Robust to symlinked
@@ -559,13 +600,13 @@ async function main(): Promise<void> {
 // whole CLI through the npm .bin shim / a symlinked checkout).
 const isMain = isEntryPoint(process.argv[1], import.meta.url);
 if (isMain) {
-  main().catch((err) => {
+  main().catch(async (err) => {
     const verbose = process.argv.includes("--verbose") || process.argv.includes("-v");
     if (verbose && err instanceof Error && err.stack) {
       console.error(err.stack);
     } else {
       console.error(formatError({ message: err instanceof Error ? err.message : String(err) }));
     }
-    process.exit(1);
+    await flushAndExit(1);
   });
 }