@gjsify/cli 0.16.4 → 0.16.6

package/lib/actions/build.d.ts

@@ -55,26 +55,42 @@ export declare class BuildAction {
      */
     private loadPluginViaGjsBundle;
     /**
-     * Bundle a single plugin entry for `--app gjs` to a cached temp file and
-     * return its path. Reuses the full `--app gjs` pipeline (exports-map-aware
-     * resolution, `node:`→`@gjsify` aliases, `--globals auto`, single-file
-     * output) via a nested `BuildAction`. The nested config carries no
-     * `bundler.plugins`, so it never recurses back into plugin resolution.
-     *
-     * Cached under `node_modules/.cache/gjsify/plugins/`, keyed by the resolved
-     * source path. Invalidated when the plugin entry OR the project lockfile is
-     * newer than the cached bundle — a dep bump rewrites the lockfile but not
-     * the plugin's own entry mtime. The one window neither mtime catches (a
-     * transitive dep edited in place) is covered by the `GJSIFY_NO_PLUGIN_CACHE=1`
-     * escape hatch. Failures are rethrown with context naming the plugin.
+     * Bundle a single plugin entry for GJS via {@link bundleFileForGjsCached} and
+     * return its path. Rethrows with context naming the plugin. (GJS's native ESM
+     * loader can't resolve a plugin's `package.json#exports` subpaths for a bare
+     * specifier; Rolldown resolves them at bundle time.)
      */
     private bundlePluginForGjs;
     /**
-     * Fresh when the cached bundle is newer than BOTH the plugin entry AND the
-     * project's lockfile (the dep-change signal). Missing bundle/source → not
-     * fresh (rebuild).
+     * Bundle a single ESM entry file to a self-contained `--app gjs` module and
+     * return its path — the shared "bundle one file for GJS" helper behind both
+     * the plugin loader (exports-map subpaths GJS can't resolve for a bare
+     * specifier) and the config loader (`node:`/npm imports GJS can't resolve for
+     * an external ESM file). Reuses the full `--app gjs` pipeline (exports-map-aware
+     * resolution, `node:`→`@gjsify` aliases, `gi://` externalized, `--globals auto`,
+     * single-file output).
+     *
+     * The nested `BuildAction` is constructed with EXPLICIT bundler options, so
+     * `buildApp` uses that configData directly and never re-enters `Config.load`
+     * — no recursion, even when the input is the very `gjsify.config.js` being
+     * loaded. `preserveDefaultExport` re-exports `default` through the side-effect
+     * entry wrapper so the file imports as a library; shebang stays unset (the
+     * artifact is imported, not executed).
+     *
+     * Cached under `node_modules/.cache/gjsify/<cacheSubdir>/`, keyed by the source
+     * path. Invalidated when the source OR the project lockfile is newer than the
+     * cached bundle (a dep bump rewrites the lockfile but not the source mtime).
+     * `<noCacheEnv>=1` forces a rebuild (covers the residual window: a transitive
+     * dep edited in place, touching neither the source nor a lockfile).
      */
-    private isPluginBundleFresh;
+    static bundleFileForGjsCached(inputPath: string, opts: {
+        cacheSubdir: string;
+        label: string;
+        verbose?: boolean;
+        noCacheEnv?: string;
+        /** Extra compile-time `define`s (e.g. rewrite the entry's `import.meta.url`). */
+        define?: Record<string, string>;
+    }): Promise<string>;
     /** Application mode */
     buildApp(app?: App, opts?: {
         watch?: boolean;

package/lib/actions/build.js

@@ -75,6 +75,22 @@ async function newestLockfileMtime(cwd) {
     }
     return newest;
 }
+/**
+ * Fresh when the cached GJS bundle is newer than BOTH the source file AND the
+ * project's lockfile (the dep-change signal). Missing bundle/source → not fresh
+ * (rebuild). Shared by the plugin + config GJS-bundle caches.
+ */
+async function isBundleFresh(outfile, sourcePath, cwd) {
+    try {
+        const outStat = await stat(outfile);
+        const srcStat = await stat(sourcePath);
+        const depMtime = await newestLockfileMtime(cwd);
+        return outStat.mtimeMs >= Math.max(srcStat.mtimeMs, depMtime);
+    }
+    catch {
+        return false;
+    }
+}
 export class BuildAction {
     configData;
     constructor(configData = {}) {
@@ -283,70 +299,71 @@ export class BuildAction {
         }
     }
     /**
-     * Bundle a single plugin entry for `--app gjs` to a cached temp file and
-     * return its path. Reuses the full `--app gjs` pipeline (exports-map-aware
-     * resolution, `node:`→`@gjsify` aliases, `--globals auto`, single-file
-     * output) via a nested `BuildAction`. The nested config carries no
-     * `bundler.plugins`, so it never recurses back into plugin resolution.
-     *
-     * Cached under `node_modules/.cache/gjsify/plugins/`, keyed by the resolved
-     * source path. Invalidated when the plugin entry OR the project lockfile is
-     * newer than the cached bundle — a dep bump rewrites the lockfile but not
-     * the plugin's own entry mtime. The one window neither mtime catches (a
-     * transitive dep edited in place) is covered by the `GJSIFY_NO_PLUGIN_CACHE=1`
-     * escape hatch. Failures are rethrown with context naming the plugin.
+     * Bundle a single plugin entry for GJS via {@link bundleFileForGjsCached} and
+     * return its path. Rethrows with context naming the plugin. (GJS's native ESM
+     * loader can't resolve a plugin's `package.json#exports` subpaths for a bare
+     * specifier; Rolldown resolves them at bundle time.)
      */
     async bundlePluginForGjs(resolvedPath, pluginName, verbose) {
-        const cwd = process.cwd();
-        const cacheDir = join(cwd, 'node_modules', '.cache', 'gjsify', 'plugins');
-        const safeName = pluginName.replace(/[^a-zA-Z0-9._-]/g, '_');
-        const outfile = join(cacheDir, `${safeName}-${shortHash(resolvedPath)}.mjs`);
-        const cacheDisabled = isTruthyEnv(process.env.GJSIFY_NO_PLUGIN_CACHE);
-        if (!cacheDisabled && (await this.isPluginBundleFresh(outfile, resolvedPath, cwd))) {
-            if (verbose)
-                console.debug(`[gjsify] plugin "${pluginName}": reusing cached GJS bundle ${outfile}`);
-            return outfile;
-        }
-        if (verbose)
-            console.debug(`[gjsify] plugin "${pluginName}": bundling for GJS → ${outfile}`);
         try {
-            await mkdir(cacheDir, { recursive: true });
-            // `--globals auto` stays on so the plugin's own runtime globals
-            // (the MDX/unified toolchain touches `document`, etc.) are injected
-            // — but that injection wraps the entry with `export * from <entry>`,
-            // which drops the `default` export the plugin factory lives on.
-            // `preserveDefaultExport` makes the wrapper re-export `default` too,
-            // so the bundled plugin imports correctly as a library.
-            // shebang is intentionally left unset — the artifact is imported,
-            // not executed, so it must NOT carry a `#!` line.
-            const pluginBuild = new BuildAction({
+            return await BuildAction.bundleFileForGjsCached(resolvedPath, {
+                cacheSubdir: 'plugins',
+                label: pluginName,
                 verbose,
-                bundler: { input: resolvedPath, output: { file: outfile } },
+                noCacheEnv: 'GJSIFY_NO_PLUGIN_CACHE',
             });
-            await pluginBuild.buildApp('gjs', { preserveDefaultExport: true });
         }
         catch (err) {
             throw new Error(`gjsify config: failed to bundle plugin "${pluginName}" for GJS ` +
-                `(needed because GJS can't import packages that use exports-map subpaths directly; ` +
-                `cache dir ${cacheDir}). (${err.message})`);
+                `(needed because GJS can't import packages that use exports-map subpaths directly). ` +
+                `(${err.message})`);
         }
-        return outfile;
     }
     /**
-     * Fresh when the cached bundle is newer than BOTH the plugin entry AND the
-     * project's lockfile (the dep-change signal). Missing bundle/source → not
-     * fresh (rebuild).
+     * Bundle a single ESM entry file to a self-contained `--app gjs` module and
+     * return its path — the shared "bundle one file for GJS" helper behind both
+     * the plugin loader (exports-map subpaths GJS can't resolve for a bare
+     * specifier) and the config loader (`node:`/npm imports GJS can't resolve for
+     * an external ESM file). Reuses the full `--app gjs` pipeline (exports-map-aware
+     * resolution, `node:`→`@gjsify` aliases, `gi://` externalized, `--globals auto`,
+     * single-file output).
+     *
+     * The nested `BuildAction` is constructed with EXPLICIT bundler options, so
+     * `buildApp` uses that configData directly and never re-enters `Config.load`
+     * — no recursion, even when the input is the very `gjsify.config.js` being
+     * loaded. `preserveDefaultExport` re-exports `default` through the side-effect
+     * entry wrapper so the file imports as a library; shebang stays unset (the
+     * artifact is imported, not executed).
+     *
+     * Cached under `node_modules/.cache/gjsify/<cacheSubdir>/`, keyed by the source
+     * path. Invalidated when the source OR the project lockfile is newer than the
+     * cached bundle (a dep bump rewrites the lockfile but not the source mtime).
+     * `<noCacheEnv>=1` forces a rebuild (covers the residual window: a transitive
+     * dep edited in place, touching neither the source nor a lockfile).
      */
-    async isPluginBundleFresh(outfile, resolvedPath, cwd) {
-        try {
-            const outStat = await stat(outfile);
-            const srcStat = await stat(resolvedPath);
-            const depMtime = await newestLockfileMtime(cwd);
-            return outStat.mtimeMs >= Math.max(srcStat.mtimeMs, depMtime);
-        }
-        catch {
-            return false;
+    static async bundleFileForGjsCached(inputPath, opts) {
+        const cwd = process.cwd();
+        const cacheDir = join(cwd, 'node_modules', '.cache', 'gjsify', opts.cacheSubdir);
+        const safeName = opts.label.replace(/[^a-zA-Z0-9._-]/g, '_');
+        const outfile = join(cacheDir, `${safeName}-${shortHash(inputPath)}.mjs`);
+        const cacheDisabled = opts.noCacheEnv ? isTruthyEnv(process.env[opts.noCacheEnv]) : false;
+        if (!cacheDisabled && (await isBundleFresh(outfile, inputPath, cwd))) {
+            if (opts.verbose)
+                console.debug(`[gjsify] reusing cached GJS bundle ${outfile}`);
+            return outfile;
         }
+        if (opts.verbose)
+            console.debug(`[gjsify] bundling ${inputPath} for GJS → ${outfile}`);
+        await mkdir(cacheDir, { recursive: true });
+        await new BuildAction({
+            verbose: opts.verbose,
+            bundler: {
+                input: inputPath,
+                output: { file: outfile },
+                ...(opts.define ? { transform: { define: opts.define } } : {}),
+            },
+        }).buildApp('gjs', { preserveDefaultExport: true });
+        return outfile;
     }
     /** Application mode */
     async buildApp(app = 'gjs', opts = {}) {

package/lib/commands/run.d.ts

@@ -2,6 +2,7 @@ import type { Command } from '../types/index.js';
 interface RunOptions {
     target: string;
     args: string[];
+    workspace?: string;
 }
 export declare const runCommand: Command<unknown, RunOptions>;
 export {};

package/lib/commands/run.js

@@ -14,11 +14,12 @@
 // as a bundle file. Everything else is a script name. Users who want
 // to disambiguate can pass `./<file>` explicitly.
 import { statSync } from 'node:fs';
-import { delimiter, join, resolve } from 'node:path';
+import { basename, delimiter, join, resolve } from 'node:path';
 import { spawn } from 'node:child_process';
 import { runGjsBundle } from '../utils/run-gjs.js';
 import { readPackageJson } from '../utils/pkg-json-edit.js';
 import { findWorkspaceRoot } from '../utils/workspace-root.js';
+import { discoverWorkspaces } from '@gjsify/workspace';
 import { isGjs } from '@gjsify/rolldown-plugin-gjsify/runtime';
 export const runCommand = {
     command: 'run <target> [args..]',
@@ -34,6 +35,16 @@ export const runCommand = {
         type: 'string',
         array: true,
         default: [],
+    })
+        .option('workspace', {
+        // npm/yarn-style `-w <name>`: run <target> as a SCRIPT in the
+        // named workspace instead of the current directory. The name
+        // matches the package.json `name`, the workspace-relative path
+        // (e.g. `cli`), or the directory basename — so both
+        // `-w eco-retrofit-cli` and `-w cli` resolve, matching npm.
+        alias: 'w',
+        type: 'string',
+        description: 'Run <target> as a script in the named workspace (by name or path), like `npm run <script> -w <name>`.',
     })
         .parserConfiguration({
         // Preserve `--` as args['--'] so callers can write
@@ -61,6 +72,12 @@ export const runCommand = {
         const positionalArgs = args.args ?? [];
         const doubleDashArgs = (args['--'] ?? []).filter((v) => typeof v === 'string');
         const extraArgs = [...positionalArgs, ...doubleDashArgs];
+        // `-w <name>` (npm/yarn parity): run <target> as a script in the named
+        // workspace's directory rather than the current one. Never file mode.
+        if (typeof args.workspace === 'string' && args.workspace.length > 0) {
+            await runScriptInWorkspace(args.workspace, target, extraArgs);
+            return;
+        }
         // Script lookup wins over file detection. Without this, a bare
         // `gjsify run build` would resolve to a file when a `./build`
         // directory exists in cwd (e.g. meson's build dir from a Vala
@@ -97,6 +114,31 @@ function looksLikeFile(target) {
         return false;
     }
 }
+/**
+ * Resolve a workspace by npm/yarn `--workspace` semantics — matching the
+ * package.json `name`, the workspace-relative path (`packages/infra/cli` or
+ * `cli`), or the directory basename — then run `script` in that workspace's
+ * directory. Mirrors `npm run <script> --workspace <name>`.
+ */
+async function runScriptInWorkspace(name, script, extraArgs) {
+    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+    let workspaces;
+    try {
+        workspaces = discoverWorkspaces(root);
+    }
+    catch (err) {
+        console.error(`gjsify run: could not read workspaces at ${root}: ${err.message}`);
+        return process.exit(1);
+    }
+    const ws = workspaces.find((w) => w.name === name || w.relativeLocation === name || basename(w.location) === name);
+    if (!ws) {
+        const available = workspaces.map((w) => w.relativeLocation).join(', ') || '<none>';
+        console.error(`gjsify run: no workspace "${name}" under ${root} (available: ${available})`);
+        // `return process.exit` — a bare exit falls through under GJS (see runScript).
+        return process.exit(1);
+    }
+    await runScript(script, extraArgs, ws.location);
+}
 /**
  * Run a script declared in the current workspace's `package.json#scripts`.
  * Mirrors `yarn run <script>` semantics:
@@ -107,20 +149,29 @@ function looksLikeFile(target) {
  *   - executed through `shell: true` so `&&` / `|` / env-var refs work
  *     exactly as in package.json scripts (matches npm/yarn)
  */
-async function runScript(script, extraArgs) {
-    const cwd = process.cwd();
+async function runScript(script, extraArgs, cwd = process.cwd()) {
     const pkgPath = join(cwd, 'package.json');
     const pkg = readPackageJson(pkgPath);
     if (!pkg) {
         console.error(`gjsify run: no package.json in ${cwd}`);
-        process.exit(1);
+        // `return process.exit` — under GJS `process.exit` cannot terminate
+        // synchronously (a parked GLib.MainLoop owns the thread): it SCHEDULES
+        // the exit and returns, so a bare call falls through. Here that reached
+        // `tokenizeSimpleCommand(literal)` with `literal === undefined` →
+        // `cannot access property "length"` → the throw raced the scheduled
+        // exit into a second `system.exit` → `m_should_exit assertion failed`
+        // → core dump. The `return` halts the handler so exactly one exit is
+        // scheduled (same discipline as commands/workspace.ts). No-op on Node.
+        return process.exit(1);
     }
     const scripts = pkg.scripts ?? {};
     const literal = scripts[script];
     if (typeof literal !== 'string') {
         const available = Object.keys(scripts).join(', ') || '<none>';
         console.error(`gjsify run: no script "${script}" in ${pkgPath} (available: ${available})`);
-        process.exit(1);
+        // See the `no package.json` branch above — a bare `process.exit` under
+        // GJS falls through to `tokenizeSimpleCommand(undefined)` and core-dumps.
+        return process.exit(1);
     }
     const monorepoRoot = findWorkspaceRoot(cwd);
     const binDirs = [join(cwd, 'node_modules', '.bin')];

package/lib/config.js

@@ -1,5 +1,93 @@
 import { APP_NAME } from './constants.js';
 import { cosmiconfig } from 'cosmiconfig';
+import { basename } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { isGjs } from '@gjsify/rolldown-plugin-gjsify/runtime';
+/**
+ * Does the failed `import()` of a config look like a MODULE-RESOLUTION failure
+ * (the config imports something GJS's ESM loader can't resolve for an external
+ * file — `node:` builtins, npm deps) rather than a syntax/eval error in the
+ * config body? Only the former is worth retrying by bundling the config.
+ */
+function isModuleResolutionFailure(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /Unsupported URI scheme|\bnode:|Cannot find (module|package)|Module not found|ERR_MODULE_NOT_FOUND|Failed to resolve/i.test(msg);
+}
+/**
+ * Load a `gjsify.config.js` that imports `node:`/npm modules under the
+ * GJS-bundled CLI by BUNDLING it first (`--app gjs`: `node:`→`@gjsify`, `gi://`
+ * externalized, `--globals auto`, one self-contained ESM), then importing that.
+ * The Node-free way to run an otherwise-unimportable config under GJS — cached +
+ * de-recursed (the nested build uses explicit options, never re-enters config
+ * loading; see `BuildAction.bundleFileForGjsCached`).
+ */
+async function loadConfigViaGjsBundle(filepath, verbose) {
+    let outfile;
+    try {
+        // Dynamic import keeps the build machinery out of config.ts's eager
+        // module graph — pulled only when a config actually needs bundling.
+        const { BuildAction } = await import('./actions/build.js');
+        outfile = await BuildAction.bundleFileForGjsCached(filepath, {
+            cacheSubdir: 'config',
+            label: basename(filepath),
+            verbose,
+            noCacheEnv: 'GJSIFY_NO_CONFIG_CACHE',
+            // The bundle lives in the cache dir, but the config commonly resolves
+            // sibling files (e.g. `readFileSync(resolve(dirname(fileURLToPath(
+            // import.meta.url)), 'package.json'))`) relative to ITS OWN location.
+            // Bake the original config's URL so those reads hit the real dir.
+            define: { 'import.meta.url': JSON.stringify(pathToFileURL(filepath).href) },
+        });
+    }
+    catch (bundleErr) {
+        throw new Error(`gjsify: failed to bundle the config ${filepath} for the GJS CLI. ` +
+            `Fixes: run the build under Node (\`npx gjsify …\`), keep the config to plain values / ` +
+            `\`process.env\`, or move settings into \`package.json#gjsify\`. (${bundleErr.message})`);
+    }
+    try {
+        const mod = (await import(pathToFileURL(outfile).href));
+        return mod.default ?? mod;
+    }
+    catch (importErr) {
+        throw new Error(`gjsify: bundled the config ${filepath} for GJS but could not import the result ` +
+            `(${outfile}). (${importErr.message})`);
+    }
+}
+/**
+ * Config-file loader for the GJS-bundled CLI (`cli.gjs.mjs`).
+ *
+ * cosmiconfig's default `.js`/`.mjs`/`.cjs` loader does `await import(href)` and,
+ * on failure, falls back to a synchronous CJS `require` — which under GJS crashes
+ * deep in the bundled require-shim with an opaque `a.shift is not a function`.
+ * The real cause: a `gjsify.config.js` that imports `node:` builtins (e.g.
+ * `node:fs` to read `package.json`) can't be resolved by GJS's ESM loader for an
+ * externally-imported module (`Unsupported URI scheme for importing: node`).
+ *
+ * Fast path: plain-value configs `import()` fine under GJS — no bundling. When
+ * the import fails on module resolution, bundle the config for GJS and import
+ * THAT (so `node:`/npm imports resolve) — so node:-importing configs work
+ * Node-free, not just fail cleanly. Genuine syntax/eval errors are rethrown
+ * as-is. The Node CLI never takes this path (its `import()` resolves `node:`).
+ */
+const gjsConfigLoader = async (filepath) => {
+    try {
+        const mod = (await import(pathToFileURL(filepath).href));
+        return mod.default ?? mod;
+    }
+    catch (err) {
+        if (!isModuleResolutionFailure(err))
+            throw err;
+        return loadConfigViaGjsBundle(filepath, Boolean(process.env.GJSIFY_DEBUG));
+    }
+};
+/**
+ * On GJS, override cosmiconfig's default JS loaders (whose require fallback
+ * crashes) with {@link gjsConfigLoader}. Empty on Node, so cosmiconfig keeps its
+ * defaults there — zero behavior change off GJS.
+ */
+const gjsConfigLoaders = isGjs()
+    ? { '.js': gjsConfigLoader, '.mjs': gjsConfigLoader, '.cjs': gjsConfigLoader }
+    : {};
 /** Default cosmiconfig search places for a given module name (matches cosmiconfig defaults). */
 function defaultSearchPlaces(name) {
     return [
@@ -89,6 +177,10 @@ export class Config {
         const fileExplorer = cosmiconfig(APP_NAME, {
             ...this.loadOptions,
             searchPlaces: (this.loadOptions.searchPlaces ?? defaultSearchPlaces(APP_NAME)).filter((p) => p !== 'package.json'),
+            // GJS: swap the crashing default JS loaders for one that surfaces an
+            // actionable error instead of `a.shift is not a function`. User-provided
+            // loaders still win. No-op on Node (gjsConfigLoaders is empty there).
+            loaders: { ...gjsConfigLoaders, ...this.loadOptions.loaders },
         });
         const fileResult = (await fileExplorer.search(searchFrom));
         const merged = {};

package/package.json

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