@gjsify/cli 0.3.21 → 0.4.3

package/lib/commands/workspace.js

@@ -0,0 +1,79 @@
+// `gjsify workspace <name> <script> [args..]` — yarn-workspace shortcut.
+//
+// Equivalent to `yarn workspace <name> run <script>`: locates the named
+// workspace in the current monorepo, then runs the script there. Used
+// extensively in gjsify's own root `package.json` (17 call sites).
+import { spawn } from 'node:child_process';
+import { discoverWorkspaces } from '@gjsify/workspace';
+import { findWorkspaceRoot } from '../utils/workspace-root.js';
+export const workspaceCommand = {
+    command: 'workspace <name> <script> [args..]',
+    description: 'Run a workspace script (`yarn workspace <name> run <script>` equivalent).',
+    builder: (yargs) => yargs
+        .positional('name', {
+        description: 'Workspace name (matches package.json `name` field).',
+        type: 'string',
+        demandOption: true,
+    })
+        .positional('script', {
+        description: 'Script name to run inside that workspace.',
+        type: 'string',
+        demandOption: true,
+    })
+        .positional('args', {
+        description: 'Extra arguments forwarded to the script.',
+        type: 'string',
+        array: true,
+    }),
+    handler: async (args) => {
+        // Walk up to the monorepo root — `gjsify workspace` is often
+        // invoked from a child workspace's script (e.g. website's
+        // `build:deps` calls `gjsify workspace @gjsify/adwaita-web …`),
+        // where process.cwd() is the child workspace, not the monorepo root.
+        const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+        const workspaces = discoverWorkspaces(root);
+        const target = workspaces.find((w) => w.name === args.name);
+        if (!target) {
+            console.error(`gjsify workspace: no workspace named "${args.name}" — discovered ${workspaces.length} workspace(s)`);
+            process.exit(1);
+        }
+        const scripts = target.manifest.scripts ?? {};
+        if (typeof scripts[args.script] !== 'string') {
+            console.error(`gjsify workspace: workspace "${args.name}" has no script "${args.script}"`);
+            process.exit(1);
+        }
+        const runner = detectPackageManager();
+        const argv = runner === 'gjsify'
+            ? ['run', args.script, ...(args.args ?? [])]
+            : ['run', args.script, ...(args.args && args.args.length > 0 ? ['--', ...args.args] : [])];
+        await new Promise((resolve, reject) => {
+            const child = spawn(runner, argv, {
+                cwd: target.location,
+                stdio: 'inherit',
+                env: process.env,
+            });
+            child.on('close', (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`${runner} ${argv.join(' ')} exited with code ${code}`));
+            });
+            child.on('error', reject);
+        }).catch((err) => {
+            console.error(err.message);
+            process.exit(1);
+        });
+        // ensureMainLoop() (called inside spawn) keeps GJS alive after the
+        // child exits — without an explicit process.exit() the success path
+        // would park the loop forever.
+        process.exit(0);
+    },
+};
+function detectPackageManager() {
+    const ua = process.env.npm_config_user_agent ?? '';
+    if (ua.startsWith('yarn/'))
+        return 'yarn';
+    if (ua.startsWith('gjsify/'))
+        return 'gjsify';
+    return 'npm';
+}

package/lib/config.js

@@ -247,7 +247,18 @@ export class Config {
         if (output.minify === undefined)
             output.minify = true;
         if (output.minify === true) {
-            output.minify = { mangle: { keepNames: { function: true, class: true } } };
+            // `keepNames: true` on output is the top-level BundlerOptions
+            // path: rolldown wires it into both `mangle.keepNames.all_true()`
+            // (function+class) AND `compress.keepNames.all_true()` for us.
+            // The previous `minify: { mangle: { keepNames: {...} } }` shape
+            // worked under npm rolldown's JS API but rolldown's serde
+            // `deserialize_minify` (deserialize_minify_options.rs:311) only
+            // accepts SimpleMinifyOptions (bool/string), so the object form
+            // was rejected by the native facade's JSON-deserializer with
+            // "data did not match any variant of untagged enum
+            // SimpleMinifyOptions". `output.keepNames` reaches the binding
+            // through the documented top-level path in both engines.
+            output.keepNames = true;
         }
         if (cliArgs.logLevel) {
             // Map esbuild log levels to Rolldown's narrower set:

package/lib/index.js

@@ -1,9 +1,14 @@
 #!/usr/bin/env node
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import { buildCommand as build, runCommand as run, infoCommand as info, 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, } from './commands/index.js';
+import { buildCommand as build, runCommand as run, infoCommand as info, 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, } from './commands/index.js';
 import { APP_NAME } from './constants.js';
-void yargs(hideBin(process.argv))
+// `parseAsync()` instead of `.argv` so the top-level await keeps the
+// process alive until command handlers complete. Under Node this is
+// cosmetic — the event loop holds the process up — but under GJS the
+// script ends as soon as the top-level synchronous flow finishes, and
+// fire-and-forget handlers silently exit before any async work runs.
+await yargs(hideBin(process.argv))
     .scriptName(APP_NAME)
     .strict()
     .command(create.command, create.description, create.builder, create.handler)
@@ -18,5 +23,8 @@ void yargs(hideBin(process.argv))
     .command(gettext.command, gettext.description, gettext.builder, gettext.handler)
     .command(gsettings.command, gsettings.description, gsettings.builder, gsettings.handler)
     .command(flatpak.command, flatpak.description, flatpak.builder, flatpak.handler)
+    .command(foreach.command, foreach.description, foreach.builder, foreach.handler)
+    .command(workspace.command, workspace.description, workspace.builder, workspace.handler)
     .demandCommand(1)
-    .help().argv;
+    .help()
+    .parseAsync();

package/lib/types/config-data.d.ts

@@ -202,7 +202,16 @@ export interface ConfigDataFlatpak {
     runtime?: 'gnome' | 'freedesktop';
     /** Runtime/SDK version, e.g. `'50'` for GNOME or `'24.08'` for Freedesktop. */
     runtimeVersion?: string;
-    /** Extra SDK extensions, e.g. `['org.freedesktop.Sdk.Extension.node24']` for build-time `yarn install`. */
+    /**
+     * Extra SDK extensions to include in the manifest, e.g.
+     * `['org.freedesktop.Sdk.Extension.llvm17']` for projects with native
+     * code that needs a specific toolchain. Leave empty (the default) for
+     * pure gjsify projects — the GNOME runtime already ships GJS + GLib
+     * + libsoup, and `gjsify build` produces a self-contained bundle that
+     * needs no build-time Node anymore. (Before Phase D-3 we added
+     * `org.freedesktop.Sdk.Extension.node24` here by default for the
+     * yarn-install + esbuild build step — that's no longer required.)
+     */
     sdkExtensions?: string[];
     /** Path components prepended to PATH inside the build sandbox. */
     appendPath?: string[];

package/lib/utils/install-backend-native.d.ts

@@ -1,2 +1,6 @@
 import type { InstallOptions } from "./install-backend.ts";
-export declare function installPackagesNative(opts: InstallOptions): Promise<void>;
+export interface InstalledTopLevel {
+    name: string;
+    version: string;
+}
+export declare function installPackagesNative(opts: InstallOptions): Promise<InstalledTopLevel[]>;