@intentius/chant 0.18.5 → 0.18.6

package/dist/cli/is-entry-point.d.ts

@@ -0,0 +1,13 @@
+/**
+ * True when the module identified by `importMetaUrl` is the process entry point
+ * (`process.argv[1]`) — i.e. run directly, not imported.
+ *
+ * A naive `import.meta.url === \`file://${process.argv[1]}\`` is a false negative
+ * whenever the invocation path crosses a symlink (pnpm, global bins, a symlinked
+ * checkout, the npm `.bin` shim, `/tmp`→`/private/tmp`): the loader canonicalises
+ * `import.meta.url` to the realpath while `argv[1]` keeps the symlink, so the CLI
+ * silently exits 0 having done nothing. Canonicalise both sides so the entry
+ * point is detected regardless of how the path was spelled.
+ */
+export declare function isEntryPoint(argv1: string | undefined, importMetaUrl: string): boolean;
+//# sourceMappingURL=is-entry-point.d.ts.map

package/dist/cli/is-entry-point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-entry-point.d.ts","sourceRoot":"","sources":["../../src/cli/is-entry-point.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAOtF"}

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AAKA,OAAO,EAAmC,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAiB9E;;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;AAiB9E;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CA2LpD"}

package/package.json

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

package/src/cli/is-entry-point.test.ts

@@ -0,0 +1,46 @@
+import { describe, test, expect, beforeAll, afterAll } from "vitest";
+import { isEntryPoint } from "./is-entry-point";
+import { mkdtempSync, writeFileSync, symlinkSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+describe("isEntryPoint", () => {
+  let dir: string;
+
+  beforeAll(() => {
+    dir = mkdtempSync(join(tmpdir(), "chant-entry-"));
+    writeFileSync(join(dir, "cli.ts"), "");
+    writeFileSync(join(dir, "marker"), "");
+    symlinkSync(join(dir, "cli.ts"), join(dir, "cli-link.ts"));
+  });
+  afterAll(() => rmSync(dir, { recursive: true, force: true }));
+
+  test("true when argv1 and import.meta.url are the same real file", () => {
+    const file = join(dir, "cli.ts");
+    expect(isEntryPoint(file, pathToFileURL(file).href)).toBe(true);
+  });
+
+  test("true when argv1 is a symlink to the file import.meta.url resolves to", () => {
+    // The regression: import.meta.url is the realpath (real cli.ts); argv1 is the
+    // symlink (cli-link.ts). A raw string compare would be false; this must be true.
+    const symlinkArg = join(dir, "cli-link.ts");
+    const realUrl = pathToFileURL(join(dir, "cli.ts")).href;
+    expect(symlinkArg).not.toBe(join(dir, "cli.ts"));
+    expect(isEntryPoint(symlinkArg, realUrl)).toBe(true);
+  });
+
+  test("false for a different file (imported, not the entry point)", () => {
+    const other = join(dir, "cli.ts");
+    const importedUrl = pathToFileURL(join(dir, "marker")).href;
+    expect(isEntryPoint(other, importedUrl)).toBe(false);
+  });
+
+  test("false when there is no argv1", () => {
+    expect(isEntryPoint(undefined, pathToFileURL(join(dir, "cli.ts")).href)).toBe(false);
+  });
+
+  test("false (not a throw) when a path does not exist", () => {
+    expect(isEntryPoint(join(dir, "gone.ts"), pathToFileURL(join(dir, "cli.ts")).href)).toBe(false);
+  });
+});

package/src/cli/is-entry-point.ts

@@ -0,0 +1,22 @@
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+/**
+ * True when the module identified by `importMetaUrl` is the process entry point
+ * (`process.argv[1]`) — i.e. run directly, not imported.
+ *
+ * A naive `import.meta.url === \`file://${process.argv[1]}\`` is a false negative
+ * whenever the invocation path crosses a symlink (pnpm, global bins, a symlinked
+ * checkout, the npm `.bin` shim, `/tmp`→`/private/tmp`): the loader canonicalises
+ * `import.meta.url` to the realpath while `argv[1]` keeps the symlink, so the CLI
+ * silently exits 0 having done nothing. Canonicalise both sides so the entry
+ * point is detected regardless of how the path was spelled.
+ */
+export function isEntryPoint(argv1: string | undefined, importMetaUrl: string): boolean {
+  if (!argv1) return false;
+  try {
+    return realpathSync(argv1) === realpathSync(fileURLToPath(importMetaUrl));
+  } catch {
+    return false;
+  }
+}

package/src/cli/main.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env tsx
 
 import { resolve } from "node:path";
+import { isEntryPoint } from "./is-entry-point";
 import { formatSuccess, formatError } from "./format";
 import { loadPlugins, resolveProjectLexicons } from "./plugins";
 import { resolveCommand, type CommandDef, type ParsedArgs } from "./registry";
@@ -536,8 +537,10 @@ async function main(): Promise<void> {
   process.exit(await match.def.handler(ctx));
 }
 
-// Only run main when executed directly, not when imported
-const isMain = import.meta.url === `file://${process.argv[1]}`;
+// Only run main when executed directly, not when imported. Robust to symlinked
+// invocation paths — see isEntryPoint (a raw string compare silently no-ops the
+// whole CLI through the npm .bin shim / a symlinked checkout).
+const isMain = isEntryPoint(process.argv[1], import.meta.url);
 if (isMain) {
   main().catch((err) => {
     const verbose = process.argv.includes("--verbose") || process.argv.includes("-v");