@gjsify/cli 0.4.0 → 0.4.3

package/lib/bundler-pick.js

@@ -24,6 +24,8 @@
 // as build errors rather than silent wrong behavior.
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
 // npm `rolldown` is a Rust crate with platform-specific prebuilds; loading
 // it eagerly at module init pulls musl-detection code that does
 // `require('node:fs')` synchronously — fine on Node, but fatal under GJS
@@ -140,13 +142,19 @@ async function tryLoadNative() {
             // a real path, then dynamic-import the resulting file:// URL.
             // Under Node a bare specifier import works directly, so we keep
             // the simpler form there.
+            //
+            // `createRequire` + `pathToFileURL` are statically imported at
+            // the top of this file so the GJS bundle inlines them via
+            // `@gjsify/module` / `@gjsify/url`. A *dynamic* `import('node:…')`
+            // would instead hit the GJS native ESM loader which doesn't
+            // know the `node:` URI scheme and throws — silently swallowed
+            // by the surrounding catch, leaving the caller to fall back
+            // to npm rolldown (which then throws ImportError for `rolldown`).
             const specifier = '@gjsify/rolldown-native';
             let target = specifier;
             if (isGjs) {
-                const { createRequire } = await import('node:module');
                 const require = createRequire(import.meta.url);
                 const resolved = require.resolve(specifier);
-                const { pathToFileURL } = await import('node:url');
                 target = pathToFileURL(resolved).href;
             }
             const mod = (await import(/* @vite-ignore */ target));

package/lib/commands/foreach.d.ts

@@ -1,6 +1,6 @@
 import type { Command } from '../types/index.js';
 interface ForeachOptions {
-    script: string;
+    script?: string;
     args?: string[];
     all?: boolean;
     parallel?: boolean;
@@ -11,6 +11,7 @@ interface ForeachOptions {
     private?: boolean;
     verbose?: boolean;
     jobs?: number;
+    exec?: boolean;
 }
 export declare const foreachCommand: Command<any, ForeachOptions>;
 export {};

package/lib/commands/foreach.js

@@ -11,14 +11,14 @@
 import { spawn } from 'node:child_process';
 import { cpus } from 'node:os';
 import { buildDependencyGraph, discoverWorkspaces, filterWorkspaces, topologicalSort, } from '@gjsify/workspace';
+import { findWorkspaceRoot } from '../utils/workspace-root.js';
 export const foreachCommand = {
-    command: 'foreach <script> [args..]',
-    description: 'Run a workspace script across all (or filtered) workspaces. Drop-in for `yarn workspaces foreach`: -A/--all, -p/--parallel, -t/--topological, --include, --exclude, --no-private.',
+    command: 'foreach [script] [args..]',
+    description: 'Run a workspace script across all (or filtered) workspaces. Drop-in for `yarn workspaces foreach`: -A/--all, -p/--parallel, -t/--topological, --include, --exclude, --no-private. Pass --exec to run an arbitrary command instead of a script.',
     builder: (yargs) => yargs
         .positional('script', {
-        description: 'Script name to run in each workspace (`run <name>`-equivalent).',
+        description: 'Script name to run in each workspace (`run <name>`-equivalent). With --exec, the command to run instead.',
         type: 'string',
-        demandOption: true,
     })
         .positional('args', {
         description: 'Extra arguments forwarded to each child invocation.',
@@ -75,24 +75,75 @@ export const foreachCommand = {
         description: 'Maximum concurrent workspaces in --parallel mode (default: cpu count).',
         type: 'number',
         alias: 'j',
+    })
+        .option('exec', {
+        description: 'Treat <script> [args..] as an arbitrary command (yarn `workspaces foreach exec`-equivalent) instead of a package.json script lookup. Workspace filtering by script presence is skipped. Use `-- <cmd> <args...>` to pass flags to the command without yargs intercepting them.',
+        type: 'boolean',
+        default: false,
+    })
+        .parserConfiguration({
+        // Preserve `--` as args._['--'] so callers can write
+        //   gjsify foreach --exec -- npm publish --tag latest
+        // without yargs grabbing --tag/--access/etc.
+        'populate--': true,
     }),
     handler: async (args) => {
-        const cwd = process.cwd();
+        // Walk up to the monorepo root — foreach is sometimes invoked
+        // from inside a child workspace's script chain.
+        const cwd = findWorkspaceRoot(process.cwd()) ?? process.cwd();
         const allWorkspaces = discoverWorkspaces(cwd);
+        const exec = args.exec === true;
+        // In --exec mode, support both
+        //   gjsify foreach --exec npm something          (no flags in command)
+        //   gjsify foreach --exec -- npm publish --tag X (flags in command)
+        // The `--` form is the typical one: `populate--: true` puts the
+        // post-separator argv into args._['--'], where yargs cannot grab
+        // --tag/--access/etc. as its own options.
+        let cmd = args.script;
+        let cmdArgs = args.args ?? [];
+        if (exec) {
+            // With populate--:true, anything after the literal `--`
+            // separator lands in top-level args['--']. yargs DOES NOT
+            // attach it to args._ — it's a sibling array.
+            const fromDoubleDash = (args['--'] ?? [])
+                .filter((v) => typeof v === 'string');
+            if (fromDoubleDash.length > 0) {
+                if (!cmd) {
+                    cmd = fromDoubleDash[0];
+                    cmdArgs = [...cmdArgs, ...fromDoubleDash.slice(1)];
+                }
+                else {
+                    cmdArgs = [...cmdArgs, ...fromDoubleDash];
+                }
+            }
+            if (!cmd) {
+                console.error('gjsify foreach --exec: missing command. Pass it after `--`, e.g. `gjsify foreach --exec -- npm publish --tag latest`.');
+                process.exit(1);
+            }
+        }
         let selected = filterWorkspaces(allWorkspaces, {
             include: args.include,
             exclude: args.exclude,
             noPrivate: args.private === false,
         });
-        // Only run on workspaces that actually have the requested script —
-        // yarn does this too, otherwise every project that doesn't declare
-        // `<script>` would fail and force the user to `--exclude` it.
-        selected = selected.filter((ws) => {
-            const scripts = ws.manifest.scripts ?? {};
-            return typeof scripts[args.script] === 'string';
-        });
+        // In script mode, only run on workspaces that actually have the
+        // requested script — yarn does this too, otherwise every project
+        // that doesn't declare `<script>` would fail and force the user to
+        // `--exclude` it. In --exec mode the command runs unconditionally
+        // (yarn's `workspaces foreach exec` semantics).
+        if (!exec) {
+            if (!cmd) {
+                console.error('gjsify foreach: missing <script> positional. Pass --exec to run an arbitrary command instead.');
+                process.exit(1);
+            }
+            const scriptName = cmd;
+            selected = selected.filter((ws) => {
+                const scripts = ws.manifest.scripts ?? {};
+                return typeof scripts[scriptName] === 'string';
+            });
+        }
         if (selected.length === 0) {
-            console.log(`gjsify foreach: no workspaces match (script="${args.script}", include=${JSON.stringify(args.include ?? [])}, exclude=${JSON.stringify(args.exclude ?? [])})`);
+            console.log(`gjsify foreach: no workspaces match (${exec ? 'exec' : 'script'}="${cmd}", include=${JSON.stringify(args.include ?? [])}, exclude=${JSON.stringify(args.exclude ?? [])})`);
             return;
         }
         if (args.topological || args['topological-dev']) {
@@ -101,44 +152,55 @@ export const foreachCommand = {
             });
             selected = topologicalSort(graph);
         }
-        const cmd = args.script;
-        const cmdArgs = args.args ?? [];
         const verbose = args.verbose === true;
-        if (args.parallel && !args.topological && !args['topological-dev']) {
-            const jobs = args.jobs && args.jobs > 0 ? args.jobs : cpus().length;
-            await runParallel(selected, cmd, cmdArgs, jobs, verbose);
-            return;
+        // `cmd` is guaranteed string at this point — both branches above
+        // exit on undefined, but TS doesn't narrow through them.
+        const finalCmd = cmd;
+        try {
+            if (args.parallel && !args.topological && !args['topological-dev']) {
+                const jobs = args.jobs && args.jobs > 0 ? args.jobs : cpus().length;
+                await runParallel(selected, finalCmd, cmdArgs, jobs, verbose, exec);
+            }
+            else if (args.parallel) {
+                // Topological + parallel: each workspace starts as soon as its
+                // deps (in the selected set) have finished. Yarn calls this
+                // "topological order with concurrency"; we cap at --jobs.
+                const jobs = args.jobs && args.jobs > 0 ? args.jobs : cpus().length;
+                await runTopologicalParallel(selected, finalCmd, cmdArgs, jobs, verbose, args['topological-dev'] === true, exec);
+            }
+            else {
+                await runSequential(selected, finalCmd, cmdArgs, verbose, exec);
+            }
         }
-        if (args.parallel) {
-            // Topological + parallel: each workspace starts as soon as its
-            // deps (in the selected set) have finished. Yarn calls this
-            // "topological order with concurrency"; we cap at --jobs.
-            const jobs = args.jobs && args.jobs > 0 ? args.jobs : cpus().length;
-            await runTopologicalParallel(selected, cmd, cmdArgs, jobs, verbose, args['topological-dev'] === true);
-            return;
+        catch (err) {
+            console.error(err.message);
+            process.exit(1);
         }
-        await runSequential(selected, cmd, cmdArgs, verbose);
+        // ensureMainLoop() (called inside spawn) keeps GJS alive after every
+        // child exits — without an explicit process.exit() the success path
+        // would park the loop forever.
+        process.exit(0);
     },
 };
-async function runSequential(workspaces, script, args, verbose) {
+async function runSequential(workspaces, script, args, verbose, exec) {
     for (const ws of workspaces) {
-        await runOne(ws, script, args, /* prefixOutput */ false, verbose);
+        await runOne(ws, script, args, /* prefixOutput */ false, verbose, exec);
     }
 }
-async function runParallel(workspaces, script, args, concurrency, verbose) {
+async function runParallel(workspaces, script, args, concurrency, verbose, exec) {
     let cursor = 0;
     const workers = [];
     for (let w = 0; w < concurrency; w++) {
         workers.push((async () => {
             while (cursor < workspaces.length) {
                 const i = cursor++;
-                await runOne(workspaces[i], script, args, /* prefixOutput */ true, verbose);
+                await runOne(workspaces[i], script, args, /* prefixOutput */ true, verbose, exec);
             }
         })());
     }
     await Promise.all(workers);
 }
-async function runTopologicalParallel(workspaces, script, args, concurrency, verbose, includeDev) {
+async function runTopologicalParallel(workspaces, script, args, concurrency, verbose, includeDev, exec) {
     const selectedNames = new Set(workspaces.map((w) => w.name));
     const remaining = new Map();
     for (const ws of workspaces) {
@@ -179,7 +241,7 @@ async function runTopologicalParallel(workspaces, script, args, concurrency, ver
                 const next = ready.sort()[0];
                 remaining.delete(next);
                 inflight++;
-                runOne(byName.get(next), script, args, /* prefixOutput */ true, verbose)
+                runOne(byName.get(next), script, args, /* prefixOutput */ true, verbose, exec)
                     .then(() => {
                     inflight--;
                     done.add(next);
@@ -205,7 +267,18 @@ async function runTopologicalParallel(workspaces, script, args, concurrency, ver
         pump();
     });
 }
-async function runOne(ws, script, args, prefixOutput, verbose) {
+async function runOne(ws, script, args, prefixOutput, verbose, exec) {
+    if (exec) {
+        // Arbitrary-command mode: spawn `<script> <args...>` directly
+        // (yarn `workspaces foreach exec`-equivalent). Used by callers
+        // that need to run binaries the workspace doesn't expose as a
+        // package.json script — e.g. `gjsify foreach --exec npm publish`.
+        if (verbose) {
+            console.error(`[${ws.name}] $ ${script} ${args.join(' ')}`);
+        }
+        await spawnPrefixed(script, args, ws.location, prefixOutput ? `[${ws.name}] ` : null);
+        return;
+    }
     // Use the same package manager that invoked us — yarn under yarn,
     // npm under npm, gjsify under gjsify. Default to `npm` for portability
     // when nothing is detectable; the script-runner (D.5) will replace

package/lib/commands/install.js

@@ -14,7 +14,7 @@
 // Workspace-aware install (`gjsify install` in a monorepo root with a
 // `"workspaces"` field) is Phase D.3 — for now we detect and surface a
 // clear error pointing at the in-progress work.
-import { existsSync, lstatSync, mkdirSync, rmSync, symlinkSync } from 'node:fs';
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
 import { spawn } from 'node:child_process';
 import { discoverWorkspaces } from '@gjsify/workspace';
@@ -168,6 +168,34 @@ async function projectInstallNative(args) {
             addDependencyEntry(pkg, name, finalRange, kind);
         }
         writePackageJson(pkgPath, pkg);
+        // Re-sync the lockfile's `requested` field with what
+        // `projectSpecsFromPackageJson()` will return on the next
+        // invocation. Without this, a `gjsify install foo` (bare name,
+        // lockfile records `"foo"`) followed by `gjsify install
+        // --immutable` (reads package.json → spec `"foo@^1.2.3"`) would
+        // surface a spurious drift error.
+        if (!args.immutable) {
+            syncLockfileRequested(cwd, projectSpecsFromPackageJson(pkg));
+        }
+    }
+}
+function syncLockfileRequested(cwd, specs) {
+    const lockPath = join(cwd, 'gjsify-lock.json');
+    if (!existsSync(lockPath))
+        return;
+    try {
+        const lock = JSON.parse(readFileSync(lockPath, 'utf-8'));
+        const sorted = [...specs].sort();
+        const current = [...(lock.requested ?? [])].sort();
+        if (sorted.length === current.length && sorted.every((s, i) => s === current[i])) {
+            return; // Already in sync; preserve byte-stability.
+        }
+        lock.requested = specs;
+        writeFileSync(lockPath, JSON.stringify(lock, null, 2) + '\n');
+    }
+    catch {
+        // Best-effort sync; if the lockfile is malformed, the next
+        // non-immutable install will rewrite it from scratch.
     }
 }
 /**
@@ -256,6 +284,156 @@ async function workspaceInstall(cwd, args) {
     if (symlinks.length > 0) {
         console.log(`gjsify install: wired ${symlinks.length} workspace symlink(s)`);
     }
+    // Hoist EVERY workspace package to the repo root's `node_modules/` so
+    // transitive workspace deps are reachable from any descendant via
+    // standard Node parent-walk resolution. yarn's `nodeLinker: node-modules`
+    // does the same thing — the entire workspace graph is materialised at
+    // the root, which is how rolldown's resolver finds e.g.
+    // `@gjsify/abort-controller/register` injected from a deeply-nested
+    // package's `node_modules/.cache/gjsify/` cache file when the consumer
+    // didn't declare a direct dep on it (auto-globals injection at build
+    // time).
+    //
+    // Without this hoist, each workspace's `node_modules/` only contains
+    // its direct declared deps, and any auto-injected register import for
+    // a workspace package the consumer didn't list as a dep externalises
+    // and the bundle fails at runtime with `Module not found`.
+    const rootBinDir = join(cwd, 'node_modules');
+    let rootHoisted = 0;
+    for (const ws of workspaces) {
+        // Skip the root workspace itself (its location IS cwd; it can't
+        // symlink itself into its own node_modules).
+        if (ws.location === cwd)
+            continue;
+        if (!ws.name)
+            continue;
+        const linkPath = join(rootBinDir, ws.name);
+        // If a symlink already exists here (from the per-workspace loop
+        // above when the root workspace declared this dep directly), it
+        // already points at the right place — skip. We don't try to
+        // remove + recreate because under GJS's Gio-backed fs polyfill,
+        // `rmSync` on a symlink can race with `symlinkSync` and surface
+        // EEXIST. A real directory at this path is also left alone —
+        // someone else (npm, yarn) seeded it and we shouldn't clobber.
+        let existsHere = false;
+        try {
+            lstatSync(linkPath);
+            existsHere = true;
+        }
+        catch { /* ENOENT */ }
+        if (existsHere)
+            continue;
+        mkdirSync(dirname(linkPath), { recursive: true });
+        const relTarget = relative(dirname(linkPath), ws.location);
+        symlinkSync(relTarget, linkPath);
+        rootHoisted++;
+    }
+    if (rootHoisted > 0) {
+        console.log(`gjsify install: hoisted ${rootHoisted} workspace(s) to root node_modules/`);
+    }
+    // Link workspace bins into `node_modules/.bin/`. Without this,
+    // `npm run <script>` (or any `node_modules/.bin`-PATH consumer)
+    // cannot find the `gjsify` binary on a fresh checkout — yarn
+    // creates these shims at install time; we need to match.
+    //
+    // Each workspace's `bin` entry maps `<binName>` → `<relative-target>`.
+    // For GJS-runnable bins, `gjsify.bin` is preferred — its target is the
+    // committed `dist/cli.gjs.mjs` bundle that exists on a fresh checkout,
+    // versus the `bin` field which typically points at `lib/index.js`
+    // (a build artifact that may not yet exist). The shim wraps the
+    // target in a shell script that picks the right interpreter (`gjs -m`
+    // for `.mjs` bundles, `node` for `.js` files).
+    const wsBinDir = join(cwd, 'node_modules', '.bin');
+    let wsBinsCreated = 0;
+    for (const ws of workspaces) {
+        const m = ws.manifest;
+        const gjsifyBin = m.gjsify?.bin;
+        const nodeBin = m.bin;
+        // For each bin name, collect both the Node-target and GJS-target
+        // when they exist. The shim prefers Node at invocation time
+        // because Node's child_process is more reliable than GJS's
+        // Gio.Subprocess polyfill (parallel-spawn close-event delivery
+        // races under heavy concurrency); GJS is the fallback for fresh
+        // checkouts where the Node target hasn't been built yet.
+        const merged = mergeWorkspaceBins(ws.name, gjsifyBin, nodeBin);
+        if (merged.size === 0)
+            continue;
+        mkdirSync(wsBinDir, { recursive: true });
+        for (const [binName, { nodeTarget, gjsTarget }] of merged) {
+            const linkPath = join(wsBinDir, binName);
+            try {
+                rmSync(linkPath, { force: true });
+            }
+            catch { /* fine */ }
+            writeFileSync(linkPath, buildBinShim(ws.location, nodeTarget, gjsTarget), { mode: 0o755 });
+            chmodSync(linkPath, 0o755);
+            wsBinsCreated++;
+        }
+    }
+    if (wsBinsCreated > 0) {
+        console.log(`gjsify install: linked ${wsBinsCreated} workspace bin(s) into node_modules/.bin/`);
+    }
+}
+/**
+ * Build a shell shim that prefers Node when its target file exists at
+ * invocation time, falling back to GJS otherwise. The runtime check is
+ * per-invocation (not at install time) so the same shim works both
+ * before and after the workspace's `lib/` has been built — a fresh
+ * checkout only has the committed `dist/cli.gjs.mjs`, while every
+ * subsequent `npm run build` produces `lib/index.js`.
+ *
+ * Both targets are absolute paths so the shim is portable across the
+ * different cwds that consumers (`yarn run`, `npm run`, direct PATH
+ * invocation) call us from.
+ */
+function buildBinShim(wsLocation, nodeTarget, gjsTarget) {
+    const nodeAbs = nodeTarget ? join(wsLocation, nodeTarget) : null;
+    const gjsAbs = gjsTarget ? join(wsLocation, gjsTarget) : null;
+    if (nodeAbs && gjsAbs) {
+        return `#!/bin/sh\nif [ -f "${nodeAbs}" ]; then\n  exec node "${nodeAbs}" "$@"\nfi\nexec gjs -m "${gjsAbs}" "$@"\n`;
+    }
+    if (nodeAbs)
+        return `#!/bin/sh\nexec node "${nodeAbs}" "$@"\n`;
+    if (gjsAbs)
+        return `#!/bin/sh\nexec gjs -m "${gjsAbs}" "$@"\n`;
+    throw new Error('buildBinShim: either nodeTarget or gjsTarget must be provided');
+}
+/**
+ * Walk a workspace's `bin` (Node) + `gjsify.bin` (GJS) declarations
+ * into a unified `<binName> → {nodeTarget?, gjsTarget?}` map. The
+ * shim built from this picks Node at runtime when its target exists,
+ * GJS otherwise.
+ */
+function mergeWorkspaceBins(pkgName, gjsifyBin, nodeBin) {
+    const out = new Map();
+    const baseName = pkgName.startsWith('@') ? pkgName.slice(pkgName.indexOf('/') + 1) : pkgName;
+    const get = (key) => {
+        let entry = out.get(key);
+        if (!entry) {
+            entry = {};
+            out.set(key, entry);
+        }
+        return entry;
+    };
+    if (typeof nodeBin === 'string') {
+        get(baseName).nodeTarget = nodeBin;
+    }
+    else if (nodeBin && typeof nodeBin === 'object') {
+        for (const [k, v] of Object.entries(nodeBin)) {
+            if (typeof v === 'string' && v.length > 0)
+                get(k).nodeTarget = v;
+        }
+    }
+    if (typeof gjsifyBin === 'string') {
+        get(baseName).gjsTarget = gjsifyBin;
+    }
+    else if (gjsifyBin && typeof gjsifyBin === 'object') {
+        for (const [k, v] of Object.entries(gjsifyBin)) {
+            if (typeof v === 'string' && v.length > 0)
+                get(k).gjsTarget = v;
+        }
+    }
+    return out;
 }
 async function projectInstallViaNpm(args) {
     const npmArgs = ['install'];

package/lib/commands/run.js

@@ -18,7 +18,7 @@ import { 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 { discoverWorkspaces } from '@gjsify/workspace';
+import { findWorkspaceRoot } from '../utils/workspace-root.js';
 export const runCommand = {
     command: 'run <target> [args..]',
     description: 'Run a script from package.json (yarn-run-style) or a GJS bundle file. If <target> resolves to a file on disk (or has a path-like prefix), it is launched via gjs with LD_LIBRARY_PATH + GI_TYPELIB_PATH set for native packages. Otherwise it is looked up in the current package.json `scripts`.',
@@ -94,8 +94,11 @@ async function runScript(script, extraArgs) {
     const fullCmd = extraArgs.length > 0
         ? `${literal} ${extraArgs.map(shellEscape).join(' ')}`
         : literal;
+    // ensureMainLoop() (called inside spawn) keeps GJS alive after the
+    // child exits — without an explicit process.exit() the success path
+    // would park the loop forever. The error path already exits.
     await new Promise((resolveOk, reject) => {
-        const child = spawn(fullCmd, { cwd, env, stdio: 'inherit', shell: true });
+        const child = spawn(fullCmd, [], { cwd, env, stdio: 'inherit', shell: true });
         child.on('close', (code) => {
             if (code === 0)
                 resolveOk();
@@ -107,30 +110,7 @@ async function runScript(script, extraArgs) {
         console.error(err.message);
         process.exit(1);
     });
-}
-function findWorkspaceRoot(start) {
-    let dir = start;
-    for (let i = 0; i < 12; i++) {
-        const pkgPath = join(dir, 'package.json');
-        if (existsSync(pkgPath)) {
-            const pkg = readPackageJson(pkgPath);
-            if (pkg?.workspaces !== undefined) {
-                try {
-                    // Sanity-check that cwd is reachable as a workspace —
-                    // otherwise we'd pick an unrelated grand-parent monorepo.
-                    const ws = discoverWorkspaces(dir);
-                    if (dir === start || ws.some((w) => w.location === start))
-                        return dir;
-                }
-                catch { /* not a usable workspace root */ }
-            }
-        }
-        const parent = resolve(dir, '..');
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return null;
+    process.exit(0);
 }
 function shellEscape(arg) {
     if (/^[a-zA-Z0-9_\-./=:@,]+$/.test(arg))

package/lib/commands/workspace.js

@@ -5,6 +5,7 @@
 // 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).',
@@ -25,7 +26,12 @@ export const workspaceCommand = {
         array: true,
     }),
     handler: async (args) => {
-        const workspaces = discoverWorkspaces(process.cwd());
+        // 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)`);
@@ -57,6 +63,10 @@ export const workspaceCommand = {
             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() {