@gjsify/cli 0.4.27 → 0.4.29

package/lib/commands/upgrade.js

@@ -12,104 +12,104 @@
 // are skipped — those are the gjsify monorepo internal links and `gjsify
 // install` resolves them locally. Only external npm specs get checked
 // against the registry.
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { homedir } from "node:os";
-import { createInterface } from "node:readline/promises";
-import { parse } from "@gjsify/semver";
-import { DEFAULT_REGISTRY, fetchPackument, parseNpmrc, } from "@gjsify/npm-registry";
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { createInterface } from 'node:readline/promises';
+import { parse } from '@gjsify/semver';
+import { DEFAULT_REGISTRY, fetchPackument, parseNpmrc } from '@gjsify/npm-registry';
 export const upgradeCommand = {
-    command: "upgrade",
-    description: "Check the npm registry for newer versions of declared dependencies and update package.json. Interactive by default; `--latest` / `--minor` / `--patch` switch to non-interactive bulk-update mode.",
+    command: 'upgrade',
+    description: 'Check the npm registry for newer versions of declared dependencies and update package.json. Interactive by default; `--latest` / `--minor` / `--patch` switch to non-interactive bulk-update mode.',
     builder: (yargs) => {
         return yargs
-            .option("latest", {
-            description: "Non-interactive: bump every dependency to its latest version (allows major).",
-            type: "boolean",
+            .option('latest', {
+            description: 'Non-interactive: bump every dependency to its latest version (allows major).',
+            type: 'boolean',
             default: false,
         })
-            .option("minor", {
-            description: "Non-interactive: bump every dependency to the latest within the same major (semver-minor + semver-patch).",
-            type: "boolean",
+            .option('minor', {
+            description: 'Non-interactive: bump every dependency to the latest within the same major (semver-minor + semver-patch).',
+            type: 'boolean',
             default: false,
         })
-            .option("patch", {
-            description: "Non-interactive: bump every dependency to the latest within the same minor (semver-patch only).",
-            type: "boolean",
+            .option('patch', {
+            description: 'Non-interactive: bump every dependency to the latest within the same minor (semver-patch only).',
+            type: 'boolean',
             default: false,
         })
-            .option("filter", {
-            description: "Only consider packages whose name matches this substring (case-insensitive). Repeatable; comma-separated values are split.",
-            type: "string",
+            .option('filter', {
+            description: 'Only consider packages whose name matches this substring (case-insensitive). Repeatable; comma-separated values are split.',
+            type: 'string',
         })
-            .option("dry-run", {
-            description: "Print the upgrade plan without writing package.json.",
-            type: "boolean",
+            .option('dry-run', {
+            description: 'Print the upgrade plan without writing package.json.',
+            type: 'boolean',
             default: false,
         })
-            .option("cwd", {
-            description: "Project directory. Default: process.cwd().",
-            type: "string",
+            .option('cwd', {
+            description: 'Project directory. Default: process.cwd().',
+            type: 'string',
         })
-            .option("yes", {
-            alias: "y",
-            description: "Interactive mode: select all without prompting.",
-            type: "boolean",
+            .option('yes', {
+            alias: 'y',
+            description: 'Interactive mode: select all without prompting.',
+            type: 'boolean',
             default: false,
         })
-            .option("verbose", {
-            description: "Print extra resolution details.",
-            type: "boolean",
+            .option('verbose', {
+            description: 'Print extra resolution details.',
+            type: 'boolean',
             default: false,
         });
     },
     handler: async (args) => {
         const cwd = resolve(args.cwd ?? process.cwd());
-        const pkgJsonPath = join(cwd, "package.json");
+        const pkgJsonPath = join(cwd, 'package.json');
         if (!existsSync(pkgJsonPath)) {
             throw new Error(`[gjsify upgrade] no package.json at ${pkgJsonPath}`);
         }
-        const rawPkg = readFileSync(pkgJsonPath, "utf-8");
+        const rawPkg = readFileSync(pkgJsonPath, 'utf-8');
         const pkg = JSON.parse(rawPkg);
         const filters = args.filter
             ? args.filter
-                .split(",")
+                .split(',')
                 .map((s) => s.trim().toLowerCase())
                 .filter(Boolean)
             : [];
         const entries = collectExternalDeps(pkg, filters);
         if (entries.length === 0) {
-            console.log("[gjsify upgrade] no external npm dependencies to check.");
+            console.log('[gjsify upgrade] no external npm dependencies to check.');
             return;
         }
         const npmrc = await loadNpmrcLight(cwd);
         const mode = args.latest
-            ? "latest"
+            ? 'latest'
             : args.minor
-                ? "minor"
+                ? 'minor'
                 : args.patch
-                    ? "patch"
-                    : "interactive";
+                    ? 'patch'
+                    : 'interactive';
         console.log(`[gjsify upgrade] checking ${entries.length} dependencies against ${npmrc.registry}…`);
         const candidates = await resolveCandidates(entries, npmrc, args.verbose ?? false, mode);
         if (candidates.length === 0) {
-            console.log("✅ all dependencies are up to date");
+            console.log('✅ all dependencies are up to date');
             return;
         }
         printTable(candidates);
         let selected;
-        if (mode === "interactive" && !args.yes) {
+        if (mode === 'interactive' && !args.yes) {
             selected = await promptSelection(candidates);
         }
-        else if (args.yes && mode === "interactive") {
-            console.log("[gjsify upgrade] -y / --yes: selecting all");
+        else if (args.yes && mode === 'interactive') {
+            console.log('[gjsify upgrade] -y / --yes: selecting all');
             selected = candidates;
         }
         else {
             selected = candidates;
         }
         if (selected.length === 0) {
-            console.log("[gjsify upgrade] nothing selected; package.json unchanged.");
+            console.log('[gjsify upgrade] nothing selected; package.json unchanged.');
             return;
         }
         if (args.dryRun) {
@@ -121,34 +121,29 @@ export const upgradeCommand = {
     },
 };
 // ─── Resolution ─────────────────────────────────────────────────────────
-const DEP_FIELDS = [
-    "dependencies",
-    "devDependencies",
-    "optionalDependencies",
-    "peerDependencies",
-];
+const DEP_FIELDS = ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies'];
 function collectExternalDeps(pkg, filters) {
     const out = [];
     for (const field of DEP_FIELDS) {
         const map = pkg[field];
-        if (!map || typeof map !== "object")
+        if (!map || typeof map !== 'object')
             continue;
         for (const [name, raw] of Object.entries(map)) {
-            if (typeof raw !== "string")
+            if (typeof raw !== 'string')
                 continue;
             if (filters.length && !filters.some((f) => name.toLowerCase().includes(f))) {
                 continue;
             }
             // Skip workspace-protocol + file: + link: + git: + http(s): specs.
-            if (raw.startsWith("workspace:") ||
-                raw.startsWith("file:") ||
-                raw.startsWith("link:") ||
-                raw.startsWith("git+") ||
-                raw.startsWith("git:") ||
-                raw.startsWith("http") ||
-                raw.startsWith("npm:") || // e.g. `foo: npm:@scope/foo@^1`
-                raw === "*" ||
-                raw === "latest") {
+            if (raw.startsWith('workspace:') ||
+                raw.startsWith('file:') ||
+                raw.startsWith('link:') ||
+                raw.startsWith('git+') ||
+                raw.startsWith('git:') ||
+                raw.startsWith('http') ||
+                raw.startsWith('npm:') || // e.g. `foo: npm:@scope/foo@^1`
+                raw === '*' ||
+                raw === 'latest') {
                 continue;
             }
             const { prefix, version } = splitRange(raw);
@@ -171,8 +166,8 @@ function collectExternalDeps(pkg, filters) {
 function splitRange(range) {
     const m = range.match(/^(\^|~|>=|<=|>|<|=)?\s*([0-9].*)$/);
     if (!m)
-        return { prefix: "", version: null };
-    const prefix = m[1] ?? "";
+        return { prefix: '', version: null };
+    const prefix = m[1] ?? '';
     const version = m[2]?.split(/\s|[|&,]/)[0] ?? null; // strip range modifiers (`||`, ` - `, etc.)
     const parsed = version ? parse(version) : null;
     return { prefix, version: parsed?.version ?? null };
@@ -190,7 +185,7 @@ async function resolveCandidates(entries, npmrc, verbose, mode) {
             const entry = entries[i];
             try {
                 const packument = await fetchPackument(entry.name, { npmrc });
-                const latest = packument["dist-tags"]?.latest;
+                const latest = packument['dist-tags']?.latest;
                 if (!latest) {
                     if (verbose)
                         console.warn(`  ${entry.name}: no dist-tags.latest, skipping`);
@@ -202,11 +197,11 @@ async function resolveCandidates(entries, npmrc, verbose, mode) {
                     continue;
                 }
                 const diff = classifyDiff(entry.currentVersion, latest);
-                if (diff === "none")
+                if (diff === 'none')
                     continue;
-                if (mode === "minor" && diff === "major")
+                if (mode === 'minor' && diff === 'major')
                     continue;
-                if (mode === "patch" && (diff === "major" || diff === "minor"))
+                if (mode === 'patch' && (diff === 'major' || diff === 'minor'))
                     continue;
                 results.push({
                     ...entry,
@@ -219,7 +214,6 @@ async function resolveCandidates(entries, npmrc, verbose, mode) {
                     console.warn(`  ${entry.name}: fetch failed (${err.message})`);
             }
         }
-        void packumentToString;
     }
     await Promise.all(Array.from({ length: cap }, () => worker()));
     results.sort((a, b) => a.name.localeCompare(b.name));
@@ -229,39 +223,39 @@ function classifyDiff(current, latest) {
     const c = parse(current);
     const l = parse(latest);
     if (!c || !l)
-        return "none";
+        return 'none';
     if (c.major !== l.major)
-        return l.major > c.major ? "major" : "none";
+        return l.major > c.major ? 'major' : 'none';
     if (c.minor !== l.minor)
-        return l.minor > c.minor ? "minor" : "none";
+        return l.minor > c.minor ? 'minor' : 'none';
     if (c.patch !== l.patch)
-        return l.patch > c.patch ? "patch" : "none";
-    if ((c.prerelease ?? []).join(".") !== (l.prerelease ?? []).join("."))
-        return "prerelease";
-    return "none";
+        return l.patch > c.patch ? 'patch' : 'none';
+    if ((c.prerelease ?? []).join('.') !== (l.prerelease ?? []).join('.'))
+        return 'prerelease';
+    return 'none';
 }
 // ─── Output / Interaction ──────────────────────────────────────────────
 const ANSI = {
-    reset: "\x1b[0m",
-    bold: "\x1b[1m",
-    dim: "\x1b[2m",
-    red: "\x1b[31m",
-    yellow: "\x1b[33m",
-    green: "\x1b[32m",
-    cyan: "\x1b[36m",
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    green: '\x1b[32m',
+    cyan: '\x1b[36m',
 };
 function colorForDiff(diff) {
     switch (diff) {
-        case "major":
+        case 'major':
             return ANSI.red;
-        case "minor":
+        case 'minor':
             return ANSI.yellow;
-        case "patch":
+        case 'patch':
             return ANSI.green;
-        case "prerelease":
+        case 'prerelease':
             return ANSI.cyan;
         default:
-            return "";
+            return '';
     }
 }
 function printTable(candidates) {
@@ -269,33 +263,33 @@ function printTable(candidates) {
     const curW = Math.max(...candidates.map((c) => c.currentRange.length), 7);
     const newW = Math.max(...candidates.map((c) => c.latestVersion.length), 6);
     const idxW = String(candidates.length).length + 2;
-    const head = " ".repeat(idxW) +
+    const head = ' '.repeat(idxW) +
         ANSI.bold +
-        "name".padEnd(nameW) +
-        "  " +
-        "current".padEnd(curW) +
-        "  " +
-        "latest".padEnd(newW) +
-        "  " +
-        "kind" +
+        'name'.padEnd(nameW) +
+        '  ' +
+        'current'.padEnd(curW) +
+        '  ' +
+        'latest'.padEnd(newW) +
+        '  ' +
+        'kind' +
         ANSI.reset;
     console.log(head);
-    console.log(" ".repeat(idxW) + ANSI.dim + "─".repeat(nameW + curW + newW + 12) + ANSI.reset);
+    console.log(' '.repeat(idxW) + ANSI.dim + '─'.repeat(nameW + curW + newW + 12) + ANSI.reset);
     for (let i = 0; i < candidates.length; i++) {
         const c = candidates[i];
         const idx = `${i + 1}.`.padEnd(idxW);
         const color = colorForDiff(c.diff);
         console.log(idx +
             c.name.padEnd(nameW) +
-            "  " +
+            '  ' +
             ANSI.dim +
             c.currentRange.padEnd(curW) +
             ANSI.reset +
-            "  " +
+            '  ' +
             color +
             c.latestVersion.padEnd(newW) +
             ANSI.reset +
-            "  " +
+            '  ' +
             color +
             c.diff +
             ANSI.reset);
@@ -303,28 +297,28 @@ function printTable(candidates) {
 }
 async function promptSelection(candidates) {
     if (!process.stdin.isTTY) {
-        console.log("[gjsify upgrade] non-TTY stdin: pass --latest / --minor / --patch (or --yes for interactive-all) to upgrade non-interactively.");
+        console.log('[gjsify upgrade] non-TTY stdin: pass --latest / --minor / --patch (or --yes for interactive-all) to upgrade non-interactively.');
         return [];
     }
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     try {
-        console.log("\nSelect upgrades: comma- or space-separated indices, " +
+        console.log('\nSelect upgrades: comma- or space-separated indices, ' +
             ANSI.bold +
-            "a" +
+            'a' +
             ANSI.reset +
-            " for all, ranges like " +
+            ' for all, ranges like ' +
             ANSI.bold +
-            "1-3" +
+            '1-3' +
             ANSI.reset +
-            ", or " +
+            ', or ' +
             ANSI.bold +
-            "ENTER" +
+            'ENTER' +
             ANSI.reset +
-            " to skip:");
-        const answer = (await rl.question("> ")).trim();
+            ' to skip:');
+        const answer = (await rl.question('> ')).trim();
         if (!answer)
             return [];
-        if (answer.toLowerCase() === "a" || answer.toLowerCase() === "all")
+        if (answer.toLowerCase() === 'a' || answer.toLowerCase() === 'all')
             return candidates;
         const picked = new Set();
         for (const token of answer.split(/[\s,]+/).filter(Boolean)) {
@@ -339,9 +333,7 @@ async function promptSelection(candidates) {
                 picked.add(Number(token) - 1);
             }
         }
-        return [...picked]
-            .filter((i) => i >= 0 && i < candidates.length)
-            .map((i) => candidates[i]);
+        return [...picked].filter((i) => i >= 0 && i < candidates.length).map((i) => candidates[i]);
     }
     finally {
         rl.close();
@@ -357,7 +349,7 @@ function writePackageJson(path, rawText, parsed, selected) {
         map[c.name] = c.prefix + c.latestVersion;
     }
     const indent = detectIndent(rawText);
-    writeFileSync(path, JSON.stringify(parsed, null, indent) + (rawText.endsWith("\n") ? "\n" : ""), "utf-8");
+    writeFileSync(path, JSON.stringify(parsed, null, indent) + (rawText.endsWith('\n') ? '\n' : ''), 'utf-8');
 }
 function detectIndent(json) {
     const m = json.match(/^\{\n( +)/);
@@ -377,11 +369,11 @@ async function loadNpmrcLight(cwd) {
     // as install-backend-native, except env-var `npm_config_registry` wins
     // over file values (matches npm's real semantics, lets the test harness
     // point at a mock registry without touching `~/.npmrc`).
-    for (const candidate of [join(homedir(), ".npmrc"), join(cwd, ".npmrc")]) {
+    for (const candidate of [join(homedir(), '.npmrc'), join(cwd, '.npmrc')]) {
         if (!existsSync(candidate))
             continue;
         try {
-            const proj = parseNpmrc(readFileSync(candidate, "utf-8"));
+            const proj = parseNpmrc(readFileSync(candidate, 'utf-8'));
             parsed = {
                 ...parsed,
                 ...proj,
@@ -397,6 +389,3 @@ async function loadNpmrcLight(cwd) {
     }
     return parsed;
 }
-function packumentToString(p) {
-    return `${p.name}@${p["dist-tags"]?.latest ?? "?"}`;
-}

package/lib/commands/workspace.js

@@ -51,9 +51,7 @@ export const workspaceCommand = {
         // on isTTY (chalk, picocolors, biome) drop colors when stdout is a
         // pipe, including GitHub Actions where the log viewer renders ANSI
         // fine.
-        const colorEnv = process.env.FORCE_COLOR !== undefined || process.env.NO_COLOR !== undefined
-            ? {}
-            : { FORCE_COLOR: '1' };
+        const colorEnv = process.env.FORCE_COLOR !== undefined || process.env.NO_COLOR !== undefined ? {} : { FORCE_COLOR: '1' };
         await new Promise((resolve, reject) => {
             const child = spawn(runner, argv, {
                 cwd: target.location,

package/lib/config.js

@@ -41,7 +41,10 @@ function merge(target, ...sources) {
     return target;
 }
 function isPlainObject(val) {
-    return typeof val === 'object' && val !== null && !Array.isArray(val) && Object.getPrototypeOf(val) === Object.prototype;
+    return (typeof val === 'object' &&
+        val !== null &&
+        !Array.isArray(val) &&
+        Object.getPrototypeOf(val) === Object.prototype);
 }
 /**
  * Read a dotted path (`a.b.c`) from a plain object. Returns `undefined` for
@@ -85,13 +88,12 @@ export class Config {
         //      package.json#gjsify exists.
         const fileExplorer = cosmiconfig(APP_NAME, {
             ...this.loadOptions,
-            searchPlaces: (this.loadOptions.searchPlaces ?? defaultSearchPlaces(APP_NAME))
-                .filter((p) => p !== 'package.json'),
+            searchPlaces: (this.loadOptions.searchPlaces ?? defaultSearchPlaces(APP_NAME)).filter((p) => p !== 'package.json'),
         });
-        const fileResult = await fileExplorer.search(searchFrom);
+        const fileResult = (await fileExplorer.search(searchFrom));
         const merged = {};
         try {
-            const pkg = await this.readPackageJSON(searchFrom);
+            const pkg = (await this.readPackageJSON(searchFrom));
             if (isPlainObject(pkg?.gjsify))
                 merge(merged, pkg.gjsify);
         }
@@ -125,8 +127,8 @@ export class Config {
         const configFile = await this.load(process.cwd());
         const configData = { ...configFile.config };
         const configFilePath = configFile.filepath || process.cwd();
-        const pkg = await this.readPackageJSON(configFilePath);
-        const tsConfig = await this.readTSConfig(configFilePath);
+        const pkg = (await this.readPackageJSON(configFilePath));
+        const tsConfig = (await this.readTSConfig(configFilePath));
         tsConfig.reflection ||= cliArgs.reflection;
         // TODO replace with `cliArgs.logLevel`
         configData.verbose = cliArgs.verbose || false;
@@ -141,12 +143,15 @@ export class Config {
             const raw = Array.isArray(cliArgs.excludeGlobals)
                 ? cliArgs.excludeGlobals.join(',')
                 : String(cliArgs.excludeGlobals);
-            const ids = raw.split(',').map((s) => s.trim()).filter(Boolean);
+            const ids = raw
+                .split(',')
+                .map((s) => s.trim())
+                .filter(Boolean);
             if (ids.length)
                 configData.excludeGlobals = [...(configData.excludeGlobals ?? []), ...ids];
         }
-        merge(configData.library ??= {}, pkg, configData.library);
-        merge(configData.typescript ??= {}, tsConfig, configData.typescript);
+        merge((configData.library ??= {}), pkg, configData.library);
+        merge((configData.typescript ??= {}), tsConfig, configData.typescript);
         // Parse `KEY=VALUE` style flags into Record<string, string>.
         // - `--define`: VALUE is a JS expression (string literals must be
         //   pre-quoted by the caller, e.g. `'"1.2.3"'`).
@@ -170,7 +175,7 @@ export class Config {
         const defineMap = parseKvPairs(cliArgs.define ?? [], 'define');
         const aliasMap = parseKvPairs(cliArgs.alias ?? [], 'alias');
         if (Object.keys(aliasMap).length) {
-            configData.aliases = { ...(configData.aliases ?? {}), ...aliasMap };
+            configData.aliases = { ...configData.aliases, ...aliasMap };
         }
         // Resolve `defineFromPackageJson` / `defineFromEnv` into raw
         // KEY=<JSON-stringified value> entries that get merged into the
@@ -289,14 +294,14 @@ export class Config {
             // CLI --define wins over package.json/env (manual overrides during
             // debugging beat declarative config).
             transform.define = {
-                ...(transform.define ?? {}),
+                ...transform.define,
                 ...fromPkgDefines,
                 ...fromEnvDefines,
                 ...defineMap,
             };
         }
         if (configData.verbose)
-            console.debug("configData", configData);
+            console.debug('configData', configData);
         return configData;
     }
 }

package/lib/index.js

@@ -6,6 +6,26 @@ import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { buildCommand as build, testCommand as test, runCommand as run, infoCommand as info, systemCheckCommand as systemCheck, checkCommand as check, showcaseCommand as showcase, createCommand as create, gresourceCommand as gresource, gettextCommand as gettext, gsettingsCommand as gsettings, flatpakCommand as flatpak, dlxCommand as dlx, installCommand as install, foreachCommand as foreach, workspaceCommand as workspace, packCommand as pack, publishCommand as publish, selfUpdateCommand as selfUpdate, generateInstallerCommand as generateInstaller, uninstallCommand as uninstall, formatCommand as format, lintCommand as lint, fixCommand as fix, upgradeCommand as upgrade, barrelsCommand as barrels, } from './commands/index.js';
 import { APP_NAME } from './constants.js';
+// Detect which runtime is executing the CLI (GJS or Node.js).
+// GJS MUST be checked first because @gjsify/process sets
+// `process.versions.node = '20.0.0'` for compatibility — a plain
+// `process.versions.node` check would be a false Node positive under GJS.
+function runtimeLabel() {
+    try {
+        const sys = globalThis.imports?.system;
+        if (sys?.version !== undefined) {
+            const v = Number(sys.version);
+            return `GJS ${Math.floor(v / 10000)}.${Math.floor((v % 10000) / 100)}.${v % 100} (SpiderMonkey)`;
+        }
+    }
+    catch {
+        /* not GJS */
+    }
+    if (typeof process !== 'undefined' && typeof process.versions?.node === 'string') {
+        return `Node.js ${process.version}`;
+    }
+    return 'unknown runtime';
+}
 // Read the version from package.json adjacent to the bundle. yargs's
 // auto-version-discovery (its `pkg-up`-driven default) doesn't reach
 // through the bundled `dist/cli.gjs.mjs` path on GJS — falls back to
@@ -68,5 +88,6 @@ await cli
     .command(fix.command, fix.description, fix.builder, fix.handler)
     .command(barrels.command, barrels.description, barrels.builder, barrels.handler)
     .demandCommand(1)
+    .epilogue(`Running on ${runtimeLabel()}`)
     .help()
     .parseAsync();

package/lib/templates/install.mjs.tmpl

@@ -45,14 +45,17 @@ Gio._promisify(Gio.Subprocess.prototype, 'wait_check_async');
 // Substituted by `gjsify generate-installer` for end-user apps.
 const DEFAULT_TARGET = '@gjsify/cli';
 const DEFAULT_BIN_NAME = 'gjsify';
-const DEFAULT_BOOTSTRAP_URL =
-    'https://github.com/gjsify/gjsify/releases/latest/download/cli.gjs.mjs';
+const DEFAULT_BOOTSTRAP_URL = 'https://github.com/gjsify/gjsify/releases/latest/download/cli.gjs.mjs';
 const DEFAULT_BOOTSTRAP_SHA256_URL = `${DEFAULT_BOOTSTRAP_URL}.sha256`;
 
 const USER_AGENT = 'gjsify-installer/1.0';
 
-function info(msg) { print(`[gjsify] ${msg}`); }
-function error(msg) { printerr(`[gjsify] ERROR: ${msg}`); }
+function info(msg) {
+    print(`[gjsify] ${msg}`);
+}
+function error(msg) {
+    printerr(`[gjsify] ERROR: ${msg}`);
+}
 
 function parseArgs() {
     const argv = system?.programArgs ?? [];
@@ -63,9 +66,8 @@ function parseArgs() {
     let bootstrapUrl = GLib.getenv('GJSIFY_INSTALL_BOOTSTRAP_URL') || DEFAULT_BOOTSTRAP_URL;
     let bootstrapSha256Url = GLib.getenv('GJSIFY_INSTALL_BOOTSTRAP_SHA256_URL');
     if (bootstrapSha256Url === null || bootstrapSha256Url === undefined) {
-        bootstrapSha256Url = bootstrapUrl === DEFAULT_BOOTSTRAP_URL
-            ? DEFAULT_BOOTSTRAP_SHA256_URL
-            : `${bootstrapUrl}.sha256`;
+        bootstrapSha256Url =
+            bootstrapUrl === DEFAULT_BOOTSTRAP_URL ? DEFAULT_BOOTSTRAP_SHA256_URL : `${bootstrapUrl}.sha256`;
     }
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
@@ -154,8 +156,7 @@ function sha256Hex(bytes) {
 function cacheDir() {
     const override = GLib.getenv('GJSIFY_INSTALL_BOOTSTRAP_CACHE');
     if (override) return override;
-    const xdg = GLib.getenv('XDG_CACHE_HOME') ||
-        GLib.build_filenamev([GLib.get_home_dir(), '.cache']);
+    const xdg = GLib.getenv('XDG_CACHE_HOME') || GLib.build_filenamev([GLib.get_home_dir(), '.cache']);
     return GLib.build_filenamev([xdg, 'gjsify', 'bootstrap']);
 }
 
@@ -164,9 +165,7 @@ function ensureDir(dir) {
 }
 
 function writeBytes(path, bytes) {
-    Gio.File.new_for_path(path).replace_contents(
-        bytes, null, false, Gio.FileCreateFlags.REPLACE_DESTINATION, null,
-    );
+    Gio.File.new_for_path(path).replace_contents(bytes, null, false, Gio.FileCreateFlags.REPLACE_DESTINATION, null);
 }
 
 async function downloadBootstrap(session, bootstrapUrl, sha256Url) {
@@ -190,7 +189,11 @@ async function downloadBootstrap(session, bootstrapUrl, sha256Url) {
         }
     }
     const dir = cacheDir();
-    try { ensureDir(dir); } catch { /* exists */ }
+    try {
+        ensureDir(dir);
+    } catch {
+        /* exists */
+    }
     const bundlePath = GLib.build_filenamev([dir, 'cli.gjs.mjs']);
     writeBytes(bundlePath, bundleBytes);
     info(`Bootstrap cached at ${bundlePath} (${bundleBytes.length} bytes)`);
@@ -220,7 +223,10 @@ async function runInstall(bundlePath, spec) {
 
 async function main() {
     const opts = parseArgs();
-    if (opts.help) { printUsage(); exit(0); }
+    if (opts.help) {
+        printUsage();
+        exit(0);
+    }
     checkGjsVersion();
 
     const session = new Soup.Session();