@gjsify/cli 0.64.4 → 0.64.5

package/lib/commands/ship.js

@@ -26,12 +26,16 @@ import { CHANNELS, CHANNEL_ENV, parseDeclaredChannel } from '../utils/channel.js
 import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join, relative, resolve } from 'node:path';
 import { Config } from '../config.js';
+import { ensurePkgDir } from './dlx.js';
 import { renderDesktopEntry, renderMetainfoApp, renderMetainfoCli, validateAppMetadata, } from '../utils/app-metadata.js';
 import { readPackageJson } from '../utils/pkg-json.js';
+import { parseSpec } from '../utils/parse-spec.js';
+import { cliVersion } from '../utils/publish-headers.js';
 import { describeExit, spawnToCompletion } from '../utils/spawn.js';
 import { buildDeb } from '../utils/ship/deb.js';
 import { deriveDepends, warnAboutGjsFloor, warnAboutNodeFloor } from '../utils/ship/depends.js';
 import { isGtkRuntimeTarget, stageAppRuntime } from '../utils/ship/app-runtime.js';
+import { acquireGtkRuntime } from '../utils/ship/gtk-runtime-acquire.js';
 import { discoverPayload } from '../utils/ship/discover.js';
 import { appDirFor, appDirPayload, appImageHostRequirements, appImageRuntimeNotice, buildAppImage, findPinnedRuntime, stampAppDirTimes, } from '../utils/ship/appimage.js';
 import { buildDmgImage, dmgVolumeDir, dmgVolumeName } from '../utils/ship/dmg.js';
@@ -411,7 +415,7 @@ async function assemble(args) {
     // `.deb`/`.rpm` `Depends:` is the promise that `node` or `gjs` is on `PATH`, and
     // carrying a second copy inside the payload would be a private interpreter no
     // distribution update ever patches.
-    const runtime = resolveCarriedRuntime(layout, settings, projectDir);
+    const runtime = await resolveCarriedRuntime(layout, settings, projectDir);
     const stageInputs = {
         bundleFiles: discovered.bundleFiles,
         launcher: renderLauncher(settings, basename(settings.bundlePath), layout, runtime.launcher),
@@ -761,21 +765,35 @@ function announceSigning(sign, notarize) {
  * thing to make non-vacuous on this layout, since a JavaScript bundle has no
  * cputype to disagree with.
  */
-function resolveCarriedRuntime(layout, settings, projectDir) {
+async function resolveCarriedRuntime(layout, settings, projectDir) {
     const empty = { files: [], launcher: {}, found: [], missing: [] };
     if (layout.os === 'linux' || settings.app !== 'node')
         return empty;
     const target = `${layout.os}-${settings.arch}`;
     if (!isGtkRuntimeTarget(target))
         return empty;
+    // The closure is fetched, not installed: a project that lists it puts a second
+    // GLib next to Homebrew's in its dev tree (see `gtk-runtime-acquire.ts`).
+    const acquired = await acquireGtkRuntime({
+        target,
+        version: cliVersion(),
+        discovery: { cwd: projectDir },
+        ensure: async (spec) => (await ensurePkgDir(parseSpec(spec), { verbose: false, cacheMaxAge: DLX_CACHE_MAX_AGE_MIN, frozen: false }))
+            .pkgDir,
+        log: (message) => console.log(`${LOG} ${message}`),
+    });
     return stageAppRuntime({
         layout,
         identity: settings,
         target,
         cwd: projectDir,
         interpreter: isNodeRuntimeTarget(target) ? resolveNodeRuntime(target, { cwd: projectDir }) : null,
+        ...(acquired.kind === 'fetched' ? { fetchedGtkRuntimeDir: acquired.dir } : {}),
+        ...(acquired.kind === 'failed' ? { gtkFetchFailure: acquired.reason } : {}),
     });
 }
+/** How long a fetched runtime stays in the dlx cache — the same week `gjsify showcase` uses. */
+const DLX_CACHE_MAX_AGE_MIN = 60 * 24 * 7;
 /**
  * Phase two: pack a stage that was assembled somewhere else.
  *

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

@@ -49,6 +49,13 @@ export interface ResolveRuntimeOptions {
      * is Bun's global-cache behaviour, which is otherwise unreachable from Node.
      */
     resolve?: ResolveInstalledPackageOptions['resolve'];
+    /**
+     * The directory of a `@gjsify/gtk-runtime-<target>` package that
+     * {@link acquireGtkRuntime} fetched for THIS run — the last candidate, after
+     * everything the author installed or pointed at. See `gtk-runtime-acquire.ts`
+     * for why it is fetched rather than installed.
+     */
+    fetchedGtkRuntimeDir?: string;
 }
 /**
  * Locate the relocated GTK closure for `target`, or `null`.
@@ -68,7 +75,11 @@ export interface ResolveRuntimeOptions {
  *     for a ship run.
  *  3. the sibling monorepo directory `../gtk-runtime-<target>/gtk`, which is what
  *     an in-repo `npm run build:bundle` writes.
- *  4. the published `@gjsify/gtk-runtime-<target>` package's `gtk/`.
+ *  4. the published `@gjsify/gtk-runtime-<target>` package's `gtk/`, when the
+ *     author installed it.
+ *  5. the same package fetched for this run (`fetchedGtkRuntimeDir`) — NOT in
+ *     node-gi's probe, because node-gi never fetches: it finds the closure inside
+ *     the `.app` this function put it in, and the layout there is the same.
  *
  * A candidate counts only when it holds BOTH the loadable-code directory and the
  * typelib directory — node-gi's own probe, restated here rather than weakened,
@@ -195,6 +206,10 @@ export interface StageAppRuntimeInput {
         nodePath: string;
         licensePath: string;
     } | null;
+    /** See {@link ResolveRuntimeOptions.fetchedGtkRuntimeDir}. */
+    fetchedGtkRuntimeDir?: string;
+    /** Why the fetch produced nothing — named in the `missing` line, so the cause is not guessed at. */
+    gtkFetchFailure?: string;
 }
 /**
  * Stage the interpreter, the GTK closure and the addon into one bundle.

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

@@ -123,7 +123,11 @@ export const NODE_GI_PACKAGE = '@gjsify/node-gi';
  *     for a ship run.
  *  3. the sibling monorepo directory `../gtk-runtime-<target>/gtk`, which is what
  *     an in-repo `npm run build:bundle` writes.
- *  4. the published `@gjsify/gtk-runtime-<target>` package's `gtk/`.
+ *  4. the published `@gjsify/gtk-runtime-<target>` package's `gtk/`, when the
+ *     author installed it.
+ *  5. the same package fetched for this run (`fetchedGtkRuntimeDir`) — NOT in
+ *     node-gi's probe, because node-gi never fetches: it finds the closure inside
+ *     the `.app` this function put it in, and the layout there is the same.
  *
  * A candidate counts only when it holds BOTH the loadable-code directory and the
  * typelib directory — node-gi's own probe, restated here rather than weakened,
@@ -155,6 +159,12 @@ export function resolveGtkRuntime(target, options = {}) {
     const entry = resolveStagedPackage(packageName, options);
     if (entry !== null)
         candidates.push({ source: packageName, dir: join(dirname(entry), 'gtk') });
+    if (options.fetchedGtkRuntimeDir !== undefined) {
+        candidates.push({
+            source: `${packageName} (fetched for this ship run)`,
+            dir: join(options.fetchedGtkRuntimeDir, 'gtk'),
+        });
+    }
     for (const candidate of candidates) {
         const libDir = join(candidate.dir, nativeSubdir);
         const typelibDir = join(candidate.dir, 'girepository-1.0');
@@ -340,8 +350,10 @@ export function stageAppRuntime(input) {
         // resolver then refuses -- a hint that is wrong is worse than none,
         // because it costs the reader the time to follow it first.
         const nativeSubdir = input.target.startsWith('win32-') ? 'bin' : 'lib';
-        missing.push(`no GTK closure — install \`${gtkRuntimePackageName(input.target)}\` (or point ` +
-            `\`GJSIFY_GTK_RUNTIME\` at a bundle directory holding \`${nativeSubdir}/\` and \`girepository-1.0/\`)`);
+        const why = input.gtkFetchFailure === undefined ? '' : ` — fetching it failed: ${input.gtkFetchFailure}`;
+        missing.push(`no GTK closure${why} — point \`GJSIFY_GTK_RUNTIME\` at a bundle directory holding ` +
+            `\`${nativeSubdir}/\` and \`girepository-1.0/\`, or install \`${gtkRuntimePackageName(input.target)}\` ` +
+            'where the build can reach it');
     }
     // node-gi's JavaScript, which the bundle `require`s by name. Staged whenever
     // the package is resolvable and reported separately from the addon: a bundle
@@ -394,6 +406,8 @@ function discoveryOptions(input) {
         options.env = input.env;
     if (input.resolve !== undefined)
         options.resolve = input.resolve;
+    if (input.fetchedGtkRuntimeDir !== undefined)
+        options.fetchedGtkRuntimeDir = input.fetchedGtkRuntimeDir;
     return options;
 }
 /**

package/lib/utils/ship/gtk-runtime-acquire.d.ts

@@ -0,0 +1,36 @@
+import { type GtkRuntimeTarget, type ResolveRuntimeOptions } from './app-runtime.js';
+export type AcquiredGtkRuntime = 
+/** Something already resolves — nothing was fetched, and nothing will be. */
+{
+    kind: 'present';
+}
+/** Fetched; `dir` is the PACKAGE directory, holding `gtk/`. */
+ | {
+    kind: 'fetched';
+    dir: string;
+}
+/** Could not be had; `reason` is what to tell the person, verbatim. */
+ | {
+    kind: 'failed';
+    reason: string;
+};
+export interface AcquireGtkRuntimeInput {
+    target: GtkRuntimeTarget;
+    /** The version to fetch: the CLI's own, because addon and closure are a matched pair. */
+    version: string;
+    /** The same discovery options the staging step will use — so "present" means what it will mean there. */
+    discovery?: ResolveRuntimeOptions;
+    /**
+     * Fetch a package spec into a cache and return its directory. Injected: the
+     * real one is `ensurePkgDir`, and a test must not touch a registry.
+     */
+    ensure: (spec: string) => Promise<string>;
+    /** One progress line. The closure is ~100 MB, so a silent first run looks like a hang. */
+    log?: (message: string) => void;
+}
+/**
+ * Make sure a GTK closure is reachable for `target`, fetching it only if nothing
+ * else provides one. Never throws: a ship run with no closure is a PARTIAL result
+ * that `stageAppRuntime` reports, not an error (see its doc).
+ */
+export declare function acquireGtkRuntime(input: AcquireGtkRuntimeInput): Promise<AcquiredGtkRuntime>;

package/lib/utils/ship/gtk-runtime-acquire.js

@@ -0,0 +1,59 @@
+// Getting the GTK closure for a ship run when the project does not carry it.
+//
+// WHY IT IS FETCHED AND NOT INSTALLED. `@gjsify/gtk-runtime-<target>` is 100 MB of
+// GLib, GObject, GTK and friends, and a project that lists it — as
+// `optionalDependencies`, which the `os`/`cpu` gate turns into "installed on every
+// Mac" — gets it into its own `node_modules`. On macOS that breaks every build and
+// every run that goes through a Homebrew GJS. Every darwin prebuild
+// carries the rpath `@loader_path` → `…/gtk-runtime-darwin-<arch>/gtk/lib` →
+// `<brew>/lib` (ADR 0023: bundle before system, `docs/prebuilds.md`), so the first
+// `dlopen` out of `node_modules/@gjsify/*-native-darwin-*` finds the bundle's
+// GLib/GObject beside the one `gjs` already loaded from Homebrew: two GObject type
+// registries in one process, which shows as `No signal 'context_response' on
+// object 'GVolumeMonitor'` and a segfault, or as `GNotificationCenterDelegate is
+// implemented in both …`. The invariant ADR 0023 names — one registry per process
+// — is violated by the dev tree itself.
+//
+// The closure is only ever needed at the moment it is COPIED into a bundle, so it
+// is acquired then: into the dlx cache (`ensurePkgDir`, the same machinery
+// `gjsify showcase` already uses for the same package), never into the project.
+// What this does NOT change: the search order in `resolveGtkRuntime()` keeps its
+// four existing candidates, so a project that still installs the package ships
+// exactly as before — it merely stays exposed to the dev-tree failure above until
+// it drops the dependency.
+//
+// EXACT VERSION, no range and no fallback. The addon's `@rpath` is
+// `@loader_path/gtk/lib` — addon and closure are a matched pair published from the
+// same release — so "the nearest published version" would be a guess about GTK ABI
+// that `assertPayloadMatchesArch` cannot check. A CLI version with no published
+// runtime (a dev or `next` build) fails with the reason named, and
+// `GJSIFY_GTK_RUNTIME` is the way past it.
+import { gtkRuntimePackageName, resolveGtkRuntime, } from './app-runtime.js';
+/**
+ * Make sure a GTK closure is reachable for `target`, fetching it only if nothing
+ * else provides one. Never throws: a ship run with no closure is a PARTIAL result
+ * that `stageAppRuntime` reports, not an error (see its doc).
+ */
+export async function acquireGtkRuntime(input) {
+    const discovery = input.discovery ?? {};
+    if (resolveGtkRuntime(input.target, discovery) !== null)
+        return { kind: 'present' };
+    const name = gtkRuntimePackageName(input.target);
+    const spec = `${name}@${input.version}`;
+    input.log?.(`${name} is not installed here, and is not meant to be — fetching ${spec} into the cache ` +
+        '(about 100 MB, once)');
+    let dir;
+    try {
+        dir = await input.ensure(spec);
+    }
+    catch (error) {
+        return { kind: 'failed', reason: error instanceof Error ? error.message : String(error) };
+    }
+    // The same completeness probe the staging step applies, so a package that
+    // resolved but holds no `gtk/` (an unpopulated checkout, a truncated cache
+    // entry) is reported HERE, with its name, instead of as a bare "no GTK closure".
+    if (resolveGtkRuntime(input.target, { ...discovery, fetchedGtkRuntimeDir: dir }) === null) {
+        return { kind: 'failed', reason: `${spec} was fetched to ${dir} but holds no complete gtk/ closure` };
+    }
+    return { kind: 'fetched', dir };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/cli",
-    "version": "0.64.4",
+    "version": "0.64.5",
     "description": "CLI for Gjsify",
     "type": "module",
     "main": "lib/index.js",
@@ -142,22 +142,22 @@
         "cli"
     ],
     "dependencies": {
-        "@gjsify/blueprint": "^0.64.4",
-        "@gjsify/buffer": "^0.64.4",
-        "@gjsify/create-app": "^0.64.4",
-        "@gjsify/node-globals": "^0.64.4",
-        "@gjsify/node-polyfills": "^0.64.4",
-        "@gjsify/npm-registry": "^0.64.4",
-        "@gjsify/resolve-npm": "^0.64.4",
-        "@gjsify/rolldown-plugin-gjsify": "^0.64.4",
-        "@gjsify/vite-plugin-blueprint": "^0.64.4",
-        "@gjsify/rolldown-plugin-pnp": "^0.64.4",
-        "@gjsify/semver": "^0.64.4",
-        "@gjsify/tar": "^0.64.4",
-        "@gjsify/tsc": "^0.64.4",
-        "@gjsify/utils": "^0.64.4",
-        "@gjsify/web-polyfills": "^0.64.4",
-        "@gjsify/workspace": "^0.64.4",
+        "@gjsify/blueprint": "^0.64.5",
+        "@gjsify/buffer": "^0.64.5",
+        "@gjsify/create-app": "^0.64.5",
+        "@gjsify/node-globals": "^0.64.5",
+        "@gjsify/node-polyfills": "^0.64.5",
+        "@gjsify/npm-registry": "^0.64.5",
+        "@gjsify/resolve-npm": "^0.64.5",
+        "@gjsify/rolldown-plugin-gjsify": "^0.64.5",
+        "@gjsify/vite-plugin-blueprint": "^0.64.5",
+        "@gjsify/rolldown-plugin-pnp": "^0.64.5",
+        "@gjsify/semver": "^0.64.5",
+        "@gjsify/tar": "^0.64.5",
+        "@gjsify/tsc": "^0.64.5",
+        "@gjsify/utils": "^0.64.5",
+        "@gjsify/web-polyfills": "^0.64.5",
+        "@gjsify/workspace": "^0.64.5",
         "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.64.4",
+        "@gjsify/unit": "^0.64.5",
         "@types/yargs": "^17.0.35",
         "typescript": "^6.0.3"
     },
     "peerDependencies": {
-        "@gjsify/oxfmt-native": "^0.64.4",
-        "@gjsify/rolldown-native": "^0.64.4"
+        "@gjsify/oxfmt-native": "^0.64.5",
+        "@gjsify/rolldown-native": "^0.64.5"
     },
     "peerDependenciesMeta": {
         "@gjsify/oxfmt-native": {