@gjsify/cli 0.4.35 → 0.4.36

package/lib/commands/tsc.js

@@ -0,0 +1,109 @@
+// `gjsify tsc [tscArgs..]` — Run the TypeScript compiler under GJS via the
+// committed `@gjsify/tsc` bundle (`@gjsify/tsc/bundle` → `dist/tsc.gjs.mjs`).
+//
+// Thin delegator: resolves the bundle path through `createRequire` anchored
+// at the workspace root (falling back to cwd), then spawns
+// `gjs -m <bundle> [tscArgs..]` with LD_LIBRARY_PATH + GI_TYPELIB_PATH set
+// for any installed native gjsify packages (mirrors `gjsify run` exactly).
+// Forwards the child's exit code so CI/scripts see real tsc semantics.
+//
+// Equivalent to invoking the `gjsify-tsc` bin from the @gjsify/tsc package
+// directly — this command just spares the user from having to discover the
+// bin path or remember the bare package name.
+//
+// @gjsify/tsc is a runtime dependency of @gjsify/cli (declared in
+// package.json) so the resolve below succeeds out of the box for any
+// `gjsify install`-managed workspace. The install-hint branch only fires
+// if the dep was removed or the consumer is running a forked CLI.
+//
+// Reference: packages/infra/cli/src/commands/run.ts (env-setup precedent).
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { detectNativePackages, buildNativeEnv } from '../utils/detect-native-packages.js';
+import { findWorkspaceRoot } from '../utils/workspace-root.js';
+export const tscCommand = {
+    command: 'tsc [tscArgs..]',
+    description: 'Run TypeScript compiler (tsc) under GJS via the @gjsify/tsc bundle. All arguments are passed through to tsc. Equivalent to `gjsify-tsc <args>` from the @gjsify/tsc bin.',
+    builder: (yargs) => 
+    // Pass-through subcommand: tsc owns the entire flag namespace
+    // (`--version`, `--help`, `--noEmit`, `-p`, …). Disable yargs's
+    // built-in `--version` / `--help` for this command so they don't
+    // intercept tsc's own flags (without this, `gjsify tsc --version`
+    // would print the gjsify CLI version instead of tsc's). Treat any
+    // unknown option as a positional so EVERY flag flows through to
+    // `tscArgs`.
+    yargs
+        .parserConfiguration({
+        'unknown-options-as-args': true,
+    })
+        .version(false)
+        .help(false)
+        .positional('tscArgs', {
+        description: 'Arguments forwarded verbatim to tsc (e.g. `--version`, `-p tsconfig.json`).',
+        type: 'string',
+        array: true,
+        default: [],
+    }),
+    handler: async (args) => {
+        // `unknown-options-as-args` parks unrecognised flags in `args._`
+        // (yargs's positional-overflow channel) — `args.tscArgs` only
+        // captures bare positionals, not pass-through flags. `_[0]` is
+        // the command name (`tsc`), strip it; the rest is forwarded
+        // verbatim, preserving the original flag order.
+        const overflow = (args._ ?? []).slice(1).map(String);
+        const explicit = args.tscArgs ?? [];
+        // When `_` has anything beyond the command name, it already
+        // includes both flags AND any bare positionals in the original
+        // order — use it directly. Fall back to the explicit positional
+        // array for the args-free invocation.
+        const tscArgs = overflow.length > 0 ? overflow : explicit;
+        const cwd = process.cwd();
+        // Anchor resolution at the workspace root so a sub-package `cwd`
+        // (e.g. `packages/web/fetch`) still finds the hoisted `@gjsify/tsc`
+        // at the root's `node_modules`. Falls back to cwd for standalone
+        // (non-monorepo) projects that have the package locally.
+        const anchorDir = findWorkspaceRoot(cwd) ?? cwd;
+        const anchor = pathToFileURL(`${anchorDir}/__gjsify_tsc__.js`).href;
+        const require = createRequire(anchor);
+        let bundlePath;
+        try {
+            bundlePath = require.resolve('@gjsify/tsc/bundle');
+        }
+        catch {
+            console.error('gjsify tsc: @gjsify/tsc is not installed.');
+            console.error('  Install with: gjsify install --save-dev @gjsify/tsc');
+            process.exit(1);
+        }
+        // Mirror `gjsify run`'s native-env composition so any future
+        // typescript-the-bundle code path that reaches a native bridge
+        // (today: none — tsc itself is pure JS) still finds the right
+        // typelibs. Costs ~one fs scan per invocation, same as run.
+        const nativePackages = detectNativePackages(cwd);
+        const nativeEnv = buildNativeEnv(nativePackages);
+        const env = {
+            ...process.env,
+            ...nativeEnv,
+        };
+        const gjsArgs = ['-m', bundlePath, ...tscArgs];
+        const child = spawn('gjs', gjsArgs, { env, stdio: 'inherit' });
+        await new Promise((resolvePromise) => {
+            child.on('close', (code) => {
+                process.exit(code ?? 1);
+            });
+            child.on('error', (err) => {
+                if (err.code === 'ENOENT') {
+                    console.error('gjsify tsc: `gjs` not found on PATH. Install GJS (e.g. `dnf install gjs`).');
+                }
+                else {
+                    console.error(`gjsify tsc: ${err.message}`);
+                }
+                process.exit(1);
+            });
+            // Never resolves naturally — process.exit() above terminates
+            // the program once the child closes. The promise just keeps
+            // the handler alive while gjs runs.
+            void resolvePromise;
+        });
+    },
+};

package/lib/commands/whoami.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from '../types/index.js';
+interface WhoamiOptions {
+    registry?: string;
+    json?: boolean;
+}
+export declare const whoamiCommand: Command<unknown, WhoamiOptions>;
+export {};

package/lib/commands/whoami.js

@@ -0,0 +1,118 @@
+// `gjsify whoami [--registry <url>] [--json]`
+//
+// Prints the npm-registry username for the current `~/.npmrc` token. The
+// natural CLI surface for the `whoami(registry, npmrc)` helper introduced
+// in #390 (originally as the dead-token-vs-missing-package diagnostic for
+// `gjsify publish`).
+//
+// Goal: maintainers should be able to verify `~/.npmrc` auth without the
+// extra `curl + Authorization: Bearer …` dance documented in AGENTS.md.
+// The four observable outcomes map to:
+//
+//   1. `{username: "..."}` from the registry  →  print
+//        Logged in as: <username>
+//        Registry:     <url>
+//      exit 0.
+//   2. `{}` from the registry  →  the token exists in npmrc but the
+//      registry no longer accepts it. Emit a clear "token appears dead or
+//      revoked" message plus the refresh instructions, exit 1.
+//   3. No `_authToken` (and no basic-auth) in any resolved npmrc  →  emit
+//      a "no token configured" message pointing at `npm login`, exit 1.
+//   4. Network / non-2xx / non-JSON error  →  surface the underlying
+//      error message + registry URL, exit 1.
+//
+// With `--json` every branch emits a single-line JSON object instead of
+// the human-readable text — useful for CI scripts that want to gate
+// behavior on `username` without parsing free-form output.
+//
+// Reference: `npm whoami` (refs/npm-cli/lib/commands/whoami.js).
+import { DEFAULT_REGISTRY, whoami } from '@gjsify/npm-registry';
+import { hasAnyCredential, loadNpmrc } from '../utils/load-npmrc.js';
+export const whoamiCommand = {
+    command: 'whoami',
+    description: 'Print the npm-registry username for the current ~/.npmrc token. Clear failure message when the token is dead, missing, or the registry is unreachable.',
+    builder: (yargs) => yargs
+        .option('registry', {
+        description: `Registry URL to probe. Default: scope-aware lookup from .npmrc (falls back to ${DEFAULT_REGISTRY}).`,
+        type: 'string',
+    })
+        .option('json', {
+        description: 'Emit `{username, registry}` (or `{error, registry}`) as a single-line JSON object.',
+        type: 'boolean',
+        default: false,
+    }),
+    handler: async (args) => {
+        const npmrc = await loadNpmrc(process.cwd());
+        // Registry resolution order matches `gjsify publish`:
+        // `--registry` flag > `$npm_config_registry` > `.npmrc` registry >
+        // `DEFAULT_REGISTRY`. The scope-aware `registryFor()` lookup is
+        // intentionally NOT used here — `whoami` is account-scoped, not
+        // package-scoped, so the user's *default* registry is what they
+        // want to verify.
+        const registry = args.registry ?? process.env.npm_config_registry ?? npmrc.registry ?? DEFAULT_REGISTRY;
+        const registryClean = registry.endsWith('/') ? registry.slice(0, -1) : registry;
+        const asJson = args.json === true;
+        // Branch 3 — no credential configured at all. Catch this before
+        // the network call so the message points at the real fix
+        // (`npm login`) instead of a registry-side 401.
+        if (!hasAnyCredential(npmrc)) {
+            if (asJson) {
+                process.stdout.write(`${JSON.stringify({ error: 'no-token-configured', registry: registryClean })}\n`);
+            }
+            else {
+                process.stderr.write([
+                    'gjsify whoami: no npm token configured.',
+                    '',
+                    `No \`_authToken\` found in ~/.npmrc / $NPM_CONFIG_USERCONFIG / .npmrc for ${registryClean}.`,
+                    '',
+                    'Add one via: npm login',
+                    'Then verify:  gjsify whoami',
+                ].join('\n') + '\n');
+            }
+            process.exit(1);
+        }
+        let result;
+        try {
+            result = await whoami(registry, npmrc);
+        }
+        catch (err) {
+            // Branch 4 — network / non-2xx / parse failure.
+            const message = err instanceof Error ? err.message : String(err);
+            if (asJson) {
+                process.stdout.write(`${JSON.stringify({ error: message, registry: registryClean })}\n`);
+            }
+            else {
+                process.stderr.write(`gjsify whoami: ${message}\n`);
+                process.stderr.write(`Registry: ${registryClean}\n`);
+            }
+            process.exit(1);
+            return; // unreachable but pleases the type narrower
+        }
+        if (result.username && result.username.length > 0) {
+            // Branch 1 — live token.
+            if (asJson) {
+                process.stdout.write(`${JSON.stringify({ username: result.username, registry: registryClean })}\n`);
+            }
+            else {
+                process.stdout.write(`Logged in as: ${result.username}\n`);
+                process.stdout.write(`Registry:     ${registryClean}\n`);
+            }
+            return;
+        }
+        // Branch 2 — dead/revoked token (registry returned `{}`).
+        if (asJson) {
+            process.stdout.write(`${JSON.stringify({ error: 'dead-token', registry: registryClean })}\n`);
+        }
+        else {
+            process.stderr.write([
+                'gjsify whoami: token appears dead or revoked (registry returned an empty whoami response).',
+                '',
+                'Refresh via: npm login',
+                'Then verify: gjsify whoami',
+                '',
+                'For the @gjsify scope, see AGENTS.md > "New @gjsify/* package: first-publish + Trusted Publisher bootstrap".',
+            ].join('\n') + '\n');
+        }
+        process.exit(1);
+    },
+};

package/lib/commands/workspace.d.ts

@@ -3,6 +3,10 @@ interface WorkspaceCmdOptions {
     name: string;
     script: string;
     args?: string[];
+    'with-dependencies'?: boolean;
+    'continue-on-error'?: boolean;
+    'include-dev'?: boolean;
+    verbose?: boolean;
 }
 export declare const workspaceCommand: Command<unknown, WorkspaceCmdOptions>;
 export {};

package/lib/commands/workspace.js

@@ -3,8 +3,19 @@
 // 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).
+//
+// With `--with-dependencies` / `-d` (synonym: `--topological` / `-t`) the
+// command first runs the SAME script in every transitive workspace
+// dependency, in topological build order, then in the target package.
+// Skips deps that don't declare the script (`--if-present` behaviour).
+// Stops on the first failure unless `--continue-on-error` is passed.
+//
+// This replaces the manual `gjsify workspace <A> build && gjsify workspace
+// <B> build && …` chains in root `build:infra` scripts: cascade build
+// failures on uninbuilt workspace deps are the single biggest local-dev
+// pain point in this monorepo.
 import { spawn } from 'node:child_process';
-import { discoverWorkspaces } from '@gjsify/workspace';
+import { buildDependencyGraph, discoverWorkspaces, topologicalSort, } from '@gjsify/workspace';
 import { findWorkspaceRoot } from '../utils/workspace-root.js';
 export const workspaceCommand = {
     command: 'workspace <name> <script> [args..]',
@@ -24,6 +35,31 @@ export const workspaceCommand = {
         description: 'Extra arguments forwarded to the script.',
         type: 'string',
         array: true,
+    })
+        .option('with-dependencies', {
+        // `-t`/`--topological` is the same flag spelled the way
+        // `gjsify foreach` already spells it — kept as an alias so
+        // muscle memory transfers.
+        description: 'Pre-build the target workspace\'s transitive workspace dependencies in topological order before running the script in the target. Deps that don\'t declare the script are skipped (--if-present behaviour). Replaces manual `gjsify workspace A build && gjsify workspace B build && …` chains.',
+        type: 'boolean',
+        alias: ['d', 't', 'topological'],
+        default: false,
+    })
+        .option('include-dev', {
+        description: 'When --with-dependencies is set, also walk devDependencies (production deps only by default — matches `gjsify foreach -t`).',
+        type: 'boolean',
+        default: false,
+    })
+        .option('continue-on-error', {
+        description: 'When --with-dependencies is set, keep running remaining deps after one fails (default: stop on first failure).',
+        type: 'boolean',
+        default: false,
+    })
+        .option('verbose', {
+        description: 'Echo every spawned command before running it.',
+        type: 'boolean',
+        alias: 'v',
+        default: false,
     }),
     handler: async (args) => {
         // Walk up to the monorepo root — `gjsify workspace` is often
@@ -31,50 +67,141 @@ export const workspaceCommand = {
         // `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);
+        const allWorkspaces = discoverWorkspaces(root);
+        const target = allWorkspaces.find((w) => w.name === args.name);
         if (!target) {
-            console.error(`gjsify workspace: no workspace named "${args.name}" — discovered ${workspaces.length} workspace(s)`);
+            console.error(`gjsify workspace: no workspace named "${args.name}" — discovered ${allWorkspaces.length} workspace(s)`);
             process.exit(1);
         }
-        const scripts = target.manifest.scripts ?? {};
-        if (typeof scripts[args.script] !== 'string') {
+        const runner = detectPackageManager();
+        const verbose = args.verbose === true;
+        const withDeps = args['with-dependencies'] === true;
+        const continueOnError = args['continue-on-error'] === true;
+        const targetScripts = target.manifest.scripts ?? {};
+        if (typeof targetScripts[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] : [])];
-        // Default FORCE_COLOR=1 unless the user explicitly opted out (matches
-        // yarn / npm / gjsify run behaviour) — without this, tools that key
-        // 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' };
-        await new Promise((resolve, reject) => {
-            const child = spawn(runner, argv, {
-                cwd: target.location,
-                stdio: 'inherit',
-                env: { ...process.env, ...colorEnv },
-            });
-            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);
+        // Build the run-list: either just the target, or its transitive
+        // workspace-dep closure in topological order followed by the
+        // target itself.
+        let runList;
+        if (withDeps) {
+            const closure = collectTransitiveClosure(target, allWorkspaces, args['include-dev'] === true);
+            // Sort the closure topologically using the shared @gjsify/workspace
+            // algorithm — same code path that drives `gjsify foreach -t`.
+            const graph = buildDependencyGraph(closure, { includeDev: args['include-dev'] === true });
+            runList = topologicalSort(graph);
+        }
+        else {
+            runList = [target];
+        }
+        const failures = [];
+        for (const ws of runList) {
+            const scripts = ws.manifest.scripts ?? {};
+            if (typeof scripts[args.script] !== 'string') {
+                // Skip deps that don't declare the script — mirrors
+                // `gjsify foreach`'s --if-present behaviour. The target
+                // itself was validated above; this branch only filters
+                // intermediate deps.
+                if (verbose)
+                    console.error(`[${ws.name}] (no "${args.script}" script — skipping)`);
+                continue;
+            }
+            try {
+                await runOne(ws, args.script, args.args ?? [], runner, verbose);
+            }
+            catch (err) {
+                const e = err instanceof Error ? err : new Error(String(err));
+                console.error(`[${ws.name}] ${e.message}`);
+                if (!continueOnError) {
+                    process.exit(1);
+                }
+                failures.push({ workspace: ws.name, error: e });
+            }
+        }
+        if (failures.length > 0) {
+            console.error(`gjsify workspace: ${failures.length} workspace(s) failed: ${failures.map((f) => f.workspace).join(', ')}`);
             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);
     },
 };
+/**
+ * Walk the workspace-dep graph from `target`, collecting every transitive
+ * workspace dependency (production + optional, plus devDependencies when
+ * `includeDev`). The returned list includes `target` itself so the caller
+ * can pass it straight to `buildDependencyGraph` / `topologicalSort`.
+ */
+function collectTransitiveClosure(target, allWorkspaces, includeDev) {
+    const byName = new Map();
+    for (const ws of allWorkspaces)
+        byName.set(ws.name, ws);
+    const seen = new Set();
+    const out = [];
+    const stack = [target];
+    while (stack.length > 0) {
+        const ws = stack.pop();
+        if (seen.has(ws.name))
+            continue;
+        seen.add(ws.name);
+        out.push(ws);
+        const m = ws.manifest;
+        const blocks = [
+            m.dependencies,
+            includeDev ? m.devDependencies : undefined,
+            m.optionalDependencies,
+            // peerDependencies excluded by default (yarn does the same)
+        ];
+        for (const block of blocks) {
+            if (!block)
+                continue;
+            for (const [depName, spec] of Object.entries(block)) {
+                if (typeof spec !== 'string')
+                    continue;
+                if (!spec.startsWith('workspace:'))
+                    continue;
+                const dep = byName.get(depName);
+                if (!dep)
+                    continue;
+                if (!seen.has(dep.name))
+                    stack.push(dep);
+            }
+        }
+    }
+    return out;
+}
+async function runOne(ws, script, extraArgs, runner, verbose) {
+    const argv = runner === 'gjsify'
+        ? ['run', script, ...extraArgs]
+        : ['run', script, ...(extraArgs.length > 0 ? ['--', ...extraArgs] : [])];
+    if (verbose) {
+        console.error(`[${ws.name}] $ ${runner} ${argv.join(' ')}`);
+    }
+    // Default FORCE_COLOR=1 unless the user explicitly opted out (matches
+    // yarn / npm / gjsify run behaviour) — without this, tools that key
+    // 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' };
+    await new Promise((resolve, reject) => {
+        const child = spawn(runner, argv, {
+            cwd: ws.location,
+            stdio: 'inherit',
+            env: { ...process.env, ...colorEnv },
+        });
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`${runner} ${argv.join(' ')} exited with code ${code}`));
+        });
+        child.on('error', reject);
+    });
+}
 function detectPackageManager() {
     const ua = process.env.npm_config_user_agent ?? '';
     if (ua.startsWith('yarn/'))

package/lib/index.js

@@ -4,7 +4,7 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 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 { 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, whoamiCommand as whoami, selfUpdateCommand as selfUpdate, generateInstallerCommand as generateInstaller, uninstallCommand as uninstall, formatCommand as format, lintCommand as lint, fixCommand as fix, upgradeCommand as upgrade, barrelsCommand as barrels, tscCommand as tsc, affectedCommand as affected, } 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
@@ -79,6 +79,7 @@ await cli
     .command(workspace.command, workspace.description, workspace.builder, workspace.handler)
     .command(pack.command, pack.description, pack.builder, pack.handler)
     .command(publish.command, publish.description, publish.builder, publish.handler)
+    .command(whoami.command, whoami.description, whoami.builder, whoami.handler)
     .command(selfUpdate.command, selfUpdate.description, selfUpdate.builder, selfUpdate.handler)
     .command(generateInstaller.command, generateInstaller.description, generateInstaller.builder, generateInstaller.handler)
     .command(uninstall.command, uninstall.description, uninstall.builder, uninstall.handler)
@@ -87,6 +88,8 @@ await cli
     .command(lint.command, lint.description, lint.builder, lint.handler)
     .command(fix.command, fix.description, fix.builder, fix.handler)
     .command(barrels.command, barrels.description, barrels.builder, barrels.handler)
+    .command(tsc.command, tsc.description, tsc.builder, tsc.handler)
+    .command(affected.command, affected.description, affected.builder, affected.handler)
     .demandCommand(1)
     .epilogue(`Running on ${runtimeLabel()}`)
     .help()