@gjsify/cli 0.58.0 → 0.59.1

package/lib/commands/install.d.ts

@@ -21,6 +21,16 @@ interface InstallOptions {
     force?: boolean;
 }
 export declare const installCommand: Command<unknown, InstallOptions>;
+/**
+ * Version of the `@gjsify/cli` the workspace at `cwd` pins: the one DECLARED in
+ * its package.json (`^`/`~`/`=` prefix stripped; only a plain version counts).
+ * The installed copy is consulted only when package.json declares no
+ * `@gjsify/cli` at all — `install` replaces a stale `node_modules`, so it must
+ * not override a declared pin (that flagged the very state being repaired).
+ * A declared non-version spec (`workspace:^`, a range, a tag) falls back to the in-repo
+ * source so the check still fires on a fresh checkout of the gjsify monorepo.
+ */
+export declare function readWorkspaceCliVersion(cwd: string): string | null;
 /**
  * Which dependency NAMES are optional across the given manifests.
  *

package/lib/commands/install.js

@@ -350,13 +350,31 @@ function readRunningCliVersion() {
     return null;
 }
 /**
- * Version of the `@gjsify/cli` the workspace at `cwd` pins. Prefers the resolved
- * install, falling back to the in-repo source so the check also fires on a fresh,
- * not-yet-installed checkout of the gjsify monorepo itself.
+ * Version of the `@gjsify/cli` the workspace at `cwd` pins: the one DECLARED in
+ * its package.json (`^`/`~`/`=` prefix stripped; only a plain version counts).
+ * The installed copy is consulted only when package.json declares no
+ * `@gjsify/cli` at all — `install` replaces a stale `node_modules`, so it must
+ * not override a declared pin (that flagged the very state being repaired).
+ * A declared non-version spec (`workspace:^`, a range, a tag) falls back to the in-repo
+ * source so the check still fires on a fresh checkout of the gjsify monorepo.
  */
-function readWorkspaceCliVersion(cwd) {
-    return (readCliVersionFrom(join(cwd, 'node_modules', CLI_PACKAGE_NAME, 'package.json')) ??
-        readCliVersionFrom(join(cwd, 'packages', 'infra', 'cli', 'package.json')));
+export function readWorkspaceCliVersion(cwd) {
+    const pkg = readPackageJson(join(cwd, 'package.json'));
+    let declared = false;
+    for (const kind of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+        const spec = pkg?.[kind]?.[CLI_PACKAGE_NAME];
+        if (typeof spec === 'string')
+            declared = true;
+        const m = typeof spec === 'string' ? /^[\^~=v]*(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)$/.exec(spec.trim()) : null;
+        if (m)
+            return m[1];
+    }
+    if (!declared) {
+        const installed = readCliVersionFrom(join(cwd, 'node_modules', CLI_PACKAGE_NAME, 'package.json'));
+        if (installed)
+            return installed;
+    }
+    return readCliVersionFrom(join(cwd, 'packages', 'infra', 'cli', 'package.json'));
 }
 /**
  * Warn (never block) when the running gjsify CLI differs from the `@gjsify/cli`

package/lib/utils/gjsify-shim.d.ts

@@ -41,6 +41,24 @@ export declare function needsSelfShim(opts: {
  * reuse it instead of creating their own.
  */
 export declare function ensureGjsifyShimOnPath(): void;
+/**
+ * Write `files` (relative path → content) into a directory NAMED BY THEIR HASH and
+ * return it. Same content, same directory: a run finds what the last one wrote and
+ * writes nothing, so shim dirs no longer pile up one per invocation (5930 in a
+ * `/tmp`, none ever removed).
+ *
+ * A reused dir, rather than one removed on exit, is what lets a child outlive its
+ * parent: a detached grandchild keeps resolving `gjsify` through the inherited PATH
+ * after the CLI that made the shim is gone, and a dir that is deleted at exit
+ * breaks it. Content-addressed means a file in it never changes, so a running
+ * process can never see a different shim than the one it was started with; each
+ * member lands by tmp+`rename`, so a concurrent run sees it whole or not at all.
+ *
+ * Lives under `$XDG_CACHE_HOME/gjsify/shim` — a `/tmp` path is world-writable, and
+ * a PATH entry there lets another local user plant a `gjsify`. A cache dir that
+ * cannot be written (read-only HOME) falls back to a private `mkdtemp` dir.
+ */
+export declare function materializeShimDir(files: Record<string, string>, root?: string): string;
 /**
  * The tree whose `node_modules` holds the running CLI and its prebuilds: the
  * install prefix above the first `node_modules` segment, or the workspace root

package/lib/utils/gjsify-shim.js

@@ -39,13 +39,15 @@
 // came through the workspace's own `node_modules/.bin/gjsify`, that shim IS the CLI
 // the tree wants. Widening this to every Node invocation would silently move in-repo
 // nested builds off the GJS bundle.
-import { mkdtempSync, mkdirSync, writeFileSync, chmodSync, existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { mkdtempSync, mkdirSync, writeFileSync, chmodSync, existsSync, readFileSync, renameSync, rmSync, } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, delimiter, relative, isAbsolute, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { isGjs } from '@gjsify/rolldown-plugin-gjsify/runtime';
 import { buildLauncherShims, buildNativeEnvPreamble, buildShLauncher, shQuoteArg } from './bin-shim.js';
 import { detectNativePackages } from './detect-native-packages.js';
+import { gjsifyCacheRoot } from './install-cache-fs.js';
 import { resolveBinOnPath } from './install-global.js';
 import { findWorkspaceRoot } from './workspace-root.js';
 let _ensured = false;
@@ -128,8 +130,6 @@ export function ensureGjsifyShimOnPath() {
     const workspaceRoot = findWorkspaceRoot(process.cwd()) ?? process.cwd();
     if (!needsSelfShim({ gjs, selfEntry, workspaceRoot }))
         return;
-    const dir = mkdtempSync(join(tmpdir(), 'gjsify-shim-'));
-    const shim = join(dir, 'gjsify');
     // The interpreter is NAMED, not pathed, matching `buildShLauncher` and
     // `buildLauncherShims`, so a missing one fails the same way on every OS. Not
     // `process.execPath`: the batch member cannot quote an interpreter argument
@@ -143,23 +143,78 @@ export function ensureGjsifyShimOnPath() {
     // beifahrer consumer on macOS: `gjsify workspace <pkg> build` died in
     // `get columns` with "Unsupported type void".
     const envPreamble = gjs ? selfShimPreamble(selfEntry) : '';
-    writeFileSync(shim, gjs
-        ? buildShLauncher(selfEntry, { isGjsBundle: true, envPreamble, gjs: interpreter })
-        : `#!/bin/sh\nexec "${interpreter}" "${selfEntry}" "$@"\n`, { mode: 0o755 });
-    chmodSync(shim, 0o755);
+    const files = {
+        gjsify: gjs
+            ? buildShLauncher(selfEntry, { isGjsBundle: true, envPreamble, gjs: interpreter })
+            : `#!/bin/sh\nexec "${interpreter}" "${selfEntry}" "$@"\n`,
+    };
     // cmd.exe and pwsh cannot run the extension-less member: not on PATHEXT, and
     // Windows has no shebang handling. `buildLauncherShims` ports npm's
     // three-sibling answer, including the IF/ELSE ERRORLEVEL handling that
     // `&&`/`||` chaining gets wrong.
     if (!gjs && process.platform === 'win32') {
         const { cmd, ps1 } = buildLauncherShims({ interpreter, interpreterArgs: [], target: selfEntry });
-        writeFileSync(`${shim}.cmd`, cmd);
-        writeFileSync(`${shim}.ps1`, ps1);
+        files['gjsify.cmd'] = cmd;
+        files['gjsify.ps1'] = ps1;
     }
+    const nodeShim = buildNodeShim(gjs, selfEntry, envPreamble);
+    if (nodeShim)
+        files[`${NODE_SHIM_SUBDIR}/node`] = nodeShim;
+    const dir = materializeShimDir(files);
     _selfShimActive = true;
     process.env.GJSIFY_SHIM_DIR = dir;
     process.env.PATH = dir + delimiter + (process.env.PATH ?? '');
-    writeNodeShim(dir, gjs, selfEntry, envPreamble);
+}
+/**
+ * Write `files` (relative path → content) into a directory NAMED BY THEIR HASH and
+ * return it. Same content, same directory: a run finds what the last one wrote and
+ * writes nothing, so shim dirs no longer pile up one per invocation (5930 in a
+ * `/tmp`, none ever removed).
+ *
+ * A reused dir, rather than one removed on exit, is what lets a child outlive its
+ * parent: a detached grandchild keeps resolving `gjsify` through the inherited PATH
+ * after the CLI that made the shim is gone, and a dir that is deleted at exit
+ * breaks it. Content-addressed means a file in it never changes, so a running
+ * process can never see a different shim than the one it was started with; each
+ * member lands by tmp+`rename`, so a concurrent run sees it whole or not at all.
+ *
+ * Lives under `$XDG_CACHE_HOME/gjsify/shim` — a `/tmp` path is world-writable, and
+ * a PATH entry there lets another local user plant a `gjsify`. A cache dir that
+ * cannot be written (read-only HOME) falls back to a private `mkdtemp` dir.
+ */
+export function materializeShimDir(files, root = gjsifyCacheRoot('shim', 'v1')) {
+    const names = Object.keys(files).sort();
+    const hash = createHash('sha256');
+    for (const name of names)
+        hash.update(`${name}\0${files[name]}\0`);
+    const key = hash.digest('hex').slice(0, 16);
+    try {
+        return writeShimDir(join(root, key), files, names);
+    }
+    catch {
+        // Unwritable cache (read-only HOME, full disk): the shim is still needed
+        // for this run, so take the per-run dir this function exists to avoid.
+        return writeShimDir(mkdtempSync(join(tmpdir(), 'gjsify-shim-')), files, names);
+    }
+}
+function writeShimDir(dir, files, names) {
+    for (const name of names) {
+        const path = join(dir, name);
+        if (existsSync(path) && readFileSync(path, 'utf8') === files[name])
+            continue;
+        mkdirSync(dirname(path), { recursive: true });
+        const tmp = `${path}.tmp.${process.pid}`;
+        try {
+            writeFileSync(tmp, files[name], { mode: 0o755 });
+            chmodSync(tmp, 0o755);
+            renameSync(tmp, path);
+        }
+        catch (err) {
+            rmSync(tmp, { force: true });
+            throw err;
+        }
+    }
+    return dir;
 }
 /**
  * The tree whose `node_modules` holds the running CLI and its prebuilds: the
@@ -268,22 +323,17 @@ export function nodeShimDir() {
  * resolves NOWHERE, and it is reachable only from a package script's PATH (see
  * {@link nodeShimDir}).
  */
-function writeNodeShim(dir, gjs, selfEntry, envPreamble) {
+function buildNodeShim(gjs, selfEntry, envPreamble) {
     if (!gjs)
-        return;
-    const sub = join(dir, NODE_SHIM_SUBDIR);
-    if (existsSync(join(sub, 'node')))
-        return; // inherited from a parent gjsify
+        return null;
     if (resolveBinOnPath('node'))
-        return; // a real Node is present — leave it alone
+        return null; // a real Node is present — leave it alone
     const interpreter = process.env.GJS_CONSOLE || 'gjs';
-    mkdirSync(sub, { recursive: true });
-    const shim = join(sub, 'node');
     // A leading FLAG is refused rather than forwarded: `node --test x.mjs` wants
     // Node's own test runner and `node -e '…'` an eval, neither of which
     // `--node-script` can honour, and yargs would take `--test` FOR the script
     // path (`unknown-options-as-args` turns an unknown flag into a positional).
-    writeFileSync(shim, '#!/bin/sh\n' +
+    return ('#!/bin/sh\n' +
         // Same SIP hop as the self-shim — see `buildSelfShimScript`.
         dyldCarryPreamble(process.platform, process.env) +
         'case "$1" in\n' +
@@ -293,6 +343,5 @@ function writeNodeShim(dir, gjs, selfEntry, envPreamble) {
         'esac\n' +
         // The same hop as the `gjsify` shim, so the same preamble.
         envPreamble +
-        `exec "${interpreter}" -m "${selfEntry}" run --node-script "$@"\n`, { mode: 0o755 });
-    chmodSync(shim, 0o755);
+        `exec "${interpreter}" -m "${selfEntry}" run --node-script "$@"\n`);
 }

package/lib/utils/install-extraneous.d.ts

@@ -59,7 +59,10 @@ export interface ExtraneousPackage {
  *   - a dot-entry like `.bin` or `.cache`, already dropped by the scan;
  *   - a package the lockfile describes but the PLATFORM filter skipped on this host.
  *     It is described, so it is not a stranger; removing the foreign-platform residue
- *     is `prune-prefix.ts`'s separate job under a separate rule.
+ *     is `prune-prefix.ts`'s separate job under a separate rule;
+ *   - anything inside the `node_modules` of a package that declares
+ *     `bundleDependencies`: its tarball put it there, so a second `--immutable` run
+ *     over the first run's own output must not refuse it.
  *
  * Descendants of an extraneous directory are collapsed away: reporting the parent
  * says everything, and the nested `@girs` tree of the incident would otherwise list

package/lib/utils/install-extraneous.js

@@ -52,7 +52,10 @@ function normalizePath(p) {
  *   - a dot-entry like `.bin` or `.cache`, already dropped by the scan;
  *   - a package the lockfile describes but the PLATFORM filter skipped on this host.
  *     It is described, so it is not a stranger; removing the foreign-platform residue
- *     is `prune-prefix.ts`'s separate job under a separate rule.
+ *     is `prune-prefix.ts`'s separate job under a separate rule;
+ *   - anything inside the `node_modules` of a package that declares
+ *     `bundleDependencies`: its tarball put it there, so a second `--immutable` run
+ *     over the first run's own output must not refuse it.
  *
  * Descendants of an extraneous directory are collapsed away: reporting the parent
  * says everything, and the nested `@girs` tree of the incident would otherwise list
@@ -60,6 +63,12 @@ function normalizePath(p) {
  */
 export function findExtraneous(opts) {
     const described = new Set(opts.expected.map((n) => normalizePath(n.installPath)));
+    // A package with `bundleDependencies` ships its own `node_modules` in the tarball
+    // (nativescript → universal-analytics + its debug/ms/uuid). Extracting it creates
+    // those directories, so the install's own output must not be refused on the next run.
+    const bundlerRoots = opts.installed
+        .filter((p) => p.bundles && !p.linked)
+        .map((p) => `${normalizePath(relative(opts.prefix, p.dir))}/node_modules/`);
     const found = [];
     for (const pkg of opts.installed) {
         if (pkg.linked)
@@ -70,6 +79,8 @@ export function findExtraneous(opts) {
             continue;
         if (described.has(installPath))
             continue;
+        if (bundlerRoots.some((root) => installPath.startsWith(root)))
+            continue;
         found.push({ installPath, name: pkg.name, version: pkg.version });
     }
     found.sort((a, b) => (a.installPath < b.installPath ? -1 : a.installPath > b.installPath ? 1 : 0));

package/lib/utils/prune-prefix.d.ts

@@ -15,6 +15,11 @@ export interface InstalledPackage {
     linked: boolean;
     /** The `os`/`cpu`/`libc` slice, absent when the manifest declares none. */
     platform?: PlatformDeclaration;
+    /**
+     * The manifest names `bundleDependencies`: its tarball ships a `node_modules` of
+     * its own, so whatever sits there came from extracting THIS package.
+     */
+    bundles?: boolean;
 }
 export interface PruneEntry {
     pkg: InstalledPackage;

package/lib/utils/prune-prefix.js

@@ -47,6 +47,7 @@ function readManifest(dir) {
             name: typeof raw.name === 'string' ? raw.name : undefined,
             version: typeof raw.version === 'string' ? raw.version : undefined,
             platform: declaresPlatform(platform) ? platform : undefined,
+            bundles: [raw.bundleDependencies, raw.bundledDependencies].some((b) => b === true || (Array.isArray(b) && b.length > 0)),
         };
     }
     catch {
@@ -102,6 +103,7 @@ function addPackage(dir, out) {
         dir,
         linked,
         platform: manifest?.platform,
+        bundles: manifest?.bundles,
     });
     // A linked package is the user's own source tree — its `node_modules` is not
     // this prefix's to prune.

package/lib/utils/ship/app-runtime.d.ts

@@ -106,8 +106,9 @@ export interface ResolvedNodeGiPackage {
  * `Layout.dirs().native`, the directory a `.app` keeps loadable code in.
  *
  * So the rule is what `require('@gjsify/node-gi/<subpath>')` can REACH:
- * `package.json` (the `exports` map is what resolves every subpath), every `.js`
- * at the package root (every `exports` target is one), and `overrides/`, which
+ * `package.json` (the `exports` map is what resolves every subpath, and itself an
+ * `exports` target for bundler hook discovery), every `.js` at the package root
+ * (every other `exports` target is one), and `overrides/`, which
  * `gi.js` loads at runtime. `tests/e2e/ship-macos` holds that rule against the
  * REAL package's `exports` map, so a node-gi release that adds an entry outside
  * this set fails there rather than in a `.app` a stranger downloaded.

package/lib/utils/ship/app-runtime.js

@@ -217,8 +217,9 @@ function resolveStagedPackage(specifier, options) {
  * `Layout.dirs().native`, the directory a `.app` keeps loadable code in.
  *
  * So the rule is what `require('@gjsify/node-gi/<subpath>')` can REACH:
- * `package.json` (the `exports` map is what resolves every subpath), every `.js`
- * at the package root (every `exports` target is one), and `overrides/`, which
+ * `package.json` (the `exports` map is what resolves every subpath, and itself an
+ * `exports` target for bundler hook discovery), every `.js` at the package root
+ * (every other `exports` target is one), and `overrides/`, which
  * `gi.js` loads at runtime. `tests/e2e/ship-macos` holds that rule against the
  * REAL package's `exports` map, so a node-gi release that adds an entry outside
  * this set fails there rather than in a `.app` a stranger downloaded.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/cli",
-    "version": "0.58.0",
+    "version": "0.59.1",
     "description": "CLI for Gjsify",
     "type": "module",
     "main": "lib/index.js",
@@ -142,22 +142,22 @@
         "cli"
     ],
     "dependencies": {
-        "@gjsify/blueprint": "^0.58.0",
-        "@gjsify/buffer": "^0.58.0",
-        "@gjsify/create-app": "^0.58.0",
-        "@gjsify/node-globals": "^0.58.0",
-        "@gjsify/node-polyfills": "^0.58.0",
-        "@gjsify/npm-registry": "^0.58.0",
-        "@gjsify/resolve-npm": "^0.58.0",
-        "@gjsify/rolldown-plugin-gjsify": "^0.58.0",
-        "@gjsify/vite-plugin-blueprint": "^0.58.0",
-        "@gjsify/rolldown-plugin-pnp": "^0.58.0",
-        "@gjsify/semver": "^0.58.0",
-        "@gjsify/tar": "^0.58.0",
-        "@gjsify/tsc": "^0.58.0",
-        "@gjsify/utils": "^0.58.0",
-        "@gjsify/web-polyfills": "^0.58.0",
-        "@gjsify/workspace": "^0.58.0",
+        "@gjsify/blueprint": "^0.59.1",
+        "@gjsify/buffer": "^0.59.1",
+        "@gjsify/create-app": "^0.59.1",
+        "@gjsify/node-globals": "^0.59.1",
+        "@gjsify/node-polyfills": "^0.59.1",
+        "@gjsify/npm-registry": "^0.59.1",
+        "@gjsify/resolve-npm": "^0.59.1",
+        "@gjsify/rolldown-plugin-gjsify": "^0.59.1",
+        "@gjsify/vite-plugin-blueprint": "^0.59.1",
+        "@gjsify/rolldown-plugin-pnp": "^0.59.1",
+        "@gjsify/semver": "^0.59.1",
+        "@gjsify/tar": "^0.59.1",
+        "@gjsify/tsc": "^0.59.1",
+        "@gjsify/utils": "^0.59.1",
+        "@gjsify/web-polyfills": "^0.59.1",
+        "@gjsify/workspace": "^0.59.1",
         "acorn": "^8.17.0",
         "cosmiconfig": "^9.0.2",
         "get-tsconfig": "^4.14.0",
@@ -166,13 +166,13 @@
         "yargs": "^18.0.0"
     },
     "devDependencies": {
-        "@gjsify/unit": "^0.58.0",
+        "@gjsify/unit": "^0.59.1",
         "@types/yargs": "^17.0.35",
         "typescript": "^6.0.3"
     },
     "peerDependencies": {
-        "@gjsify/oxfmt-native": "^0.58.0",
-        "@gjsify/rolldown-native": "^0.58.0"
+        "@gjsify/oxfmt-native": "^0.59.1",
+        "@gjsify/rolldown-native": "^0.59.1"
     },
     "peerDependenciesMeta": {
         "@gjsify/oxfmt-native": {