@gjsify/cli 0.51.1 → 0.53.0

package/lib/commands/flatpak/sources.js

@@ -19,6 +19,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { Buffer } from 'node:buffer';
+import { FLATPAK_SOURCES_FILE } from './utils.js';
 /** Checksum algorithms flatpak-builder accepts on a `file` source. */
 const FLATPAK_ALGOS = new Set(['sha256', 'sha512']);
 /** Parse an SRI integrity (`sha512-<base64>`) into `{ algorithm, hex }`. Mirrors
@@ -219,7 +220,7 @@ export const flatpakSourcesCommand = {
             .option('out', {
             description: 'Output JSON sources file',
             type: 'string',
-            default: 'gjsify-sources.json',
+            default: FLATPAK_SOURCES_FILE,
             normalize: true,
         })
             .option('cache-root', {
@@ -277,7 +278,7 @@ export const flatpakSourcesCommand = {
         }
         // Stable order (by url) so the generated file diffs cleanly across runs.
         const sources = [...byHex.values()].sort((a, b) => (a.url < b.url ? -1 : a.url > b.url ? 1 : 0));
-        const out = resolve(cwd, args.out ?? 'gjsify-sources.json');
+        const out = resolve(cwd, args.out ?? FLATPAK_SOURCES_FILE);
         mkdirSync(dirname(out), { recursive: true });
         writeFileSync(out, JSON.stringify(sources, null, 2) + '\n');
         console.log(`[gjsify flatpak sources] wrote ${out} — ${sources.length} tarball source(s) from ${type} lockfile` +
@@ -285,7 +286,7 @@ export const flatpakSourcesCommand = {
             (skippedSri ? `, ${skippedSri} without a usable integrity skipped` : '') +
             (skippedAlgo ? `, ${skippedAlgo} non-sha256/512 skipped` : ''));
         if (args.printModule) {
-            console.error(buildModuleSnippet(args.out ?? 'gjsify-sources.json', cacheRoot));
+            console.error(buildModuleSnippet(args.out ?? FLATPAK_SOURCES_FILE, cacheRoot));
         }
     },
 };

package/lib/commands/flatpak/sync-flathub.d.ts

@@ -1,6 +1,7 @@
 import type { Command } from '../../types/index.js';
 interface SyncFlathubOptions {
     version?: string;
+    sourcesFile?: string;
     appId?: string;
     flathubRepo?: string;
     commit?: string;
@@ -22,5 +23,6 @@ export declare function editManifest(original: string, args: {
     tag: string;
     commit: string;
     sourceIndex?: number;
+    sourcesFile?: string;
 }): string;
 export {};

package/lib/commands/flatpak/sync-flathub.js

@@ -11,7 +11,8 @@
 //   3. Resolve commit SHA via `git rev-list -n 1 <version>`
 //   4. Clone (or update) the flathub tracking-repo into $XDG_CACHE_HOME
 //   5. Surgically edit the manifest: modules[].sources[].{tag,commit}
-//      plus x-checker-data block (inject if missing)
+//      plus x-checker-data block (inject if missing), and carry over the
+//      offline source list (see `offline sources` below)
 //   6. Create a branch, commit the changes
 //   7. (unless --no-pr) push + open a PR via `gh pr create`
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
@@ -21,7 +22,7 @@ import { execFile } from 'node:child_process';
 import { describeExit, spawnToCompletion } from '../../utils/spawn.js';
 import { promisify } from 'node:util';
 import { Config } from '../../config.js';
-import { readPackageJson } from './utils.js';
+import { FLATPAK_SOURCES_FILE, readPackageJson } from './utils.js';
 const execFileAsync = promisify(execFile);
 export const flatpakSyncFlathubCommand = {
     command: 'sync-flathub',
@@ -51,6 +52,12 @@ export const flatpakSyncFlathubCommand = {
             .option('branch', {
             description: 'Branch name in the flathub-repo. Default: `update-to-<version>`.',
             type: 'string',
+        })
+            .option('sources-file', {
+            description: 'Generated offline tarball list to carry into the Flathub repo and name in the manifest. ' +
+                `Default: \`${FLATPAK_SOURCES_FILE}\`. Skipped when the tag does not carry it.`,
+            type: 'string',
+            default: FLATPAK_SOURCES_FILE,
         })
             .option('source-index', {
             description: 'Index into modules[0].sources[] to update (when manifest has multiple sources). Default: first `type: git` source.',
@@ -105,13 +112,33 @@ export const flatpakSyncFlathubCommand = {
         if (!existsSync(manifestPath)) {
             throw new Error(`[gjsify flatpak sync-flathub] Flathub manifest not found at ${manifestPath} — wrong appId / wrong flathub-repo?`);
         }
+        // Read AT THE TAG, not from the working tree: the manifest is about to pin
+        // that tag, and a list taken from an edited checkout would describe a tree
+        // nobody can get. Absent is the ordinary case for an app that installs
+        // online or vendors its dependencies, so it is a skip and not an error.
+        const sourcesFile = args.sourcesFile ?? FLATPAK_SOURCES_FILE;
+        const offline = await readSourceListAtTag(cwd, version, sourcesFile, args.verbose);
+        let offlineCopied = false;
+        if (offline !== null) {
+            const dest = join(cloneDir, sourcesFile);
+            offlineCopied = !existsSync(dest) || readFileSync(dest, 'utf-8') !== offline;
+            if (offlineCopied) {
+                writeFileSync(dest, offline, 'utf-8');
+                console.log(`[gjsify flatpak sync-flathub] ${sourcesFile} copied from ${version}`);
+            }
+        }
         const original = readFileSync(manifestPath, 'utf-8');
         const updated = editManifest(original, {
             tag: version,
             commit: commitSha,
             sourceIndex: args.sourceIndex,
+            sourcesFile: offline !== null ? sourcesFile : undefined,
         });
-        if (updated === original) {
+        // NOT `updated === original` alone: the tarball list changes whenever a
+        // dependency does, so a release can need a PR with the pin unmoved. That
+        // test used to be the only one, and it would have returned "nothing to do"
+        // over a Flathub repo carrying a stale list.
+        if (updated === original && !offlineCopied) {
             console.log(`[gjsify flatpak sync-flathub] manifest already at ${version} — nothing to do.`);
             return;
         }
@@ -130,6 +157,88 @@ export const flatpakSyncFlathubCommand = {
     },
 };
 // ─── Internal helpers ────────────────────────────────────────────────────
+/**
+ * The generated source list as of `tag`, or null when the tag does not carry one.
+ *
+ * `git show <tag>:<path>` rather than reading the working tree, so the file that
+ * travels to Flathub is the one the pinned commit actually contains.
+ *
+ * WHAT COMES BACK IS CHECKED, not just whether the command succeeded. A missing
+ * path makes real `git show` exit non-zero, so the obvious version of this
+ * function looks complete — and it treats an EMPTY answer as "the file exists
+ * and is empty", which then writes an empty file into the Flathub repo and
+ * names it in the manifest. That is strictly worse than skipping: the build
+ * still cannot install, and now the manifest says it can. Caught by the
+ * sync-flathub E2E, whose git stub answers every unknown subcommand with exit 0
+ * and no output.
+ *
+ * A blank answer is a skip. Content that is not a non-empty array of sources is
+ * an ERROR, because this file has exactly one producer (`gjsify flatpak
+ * sources`) and anything else means something upstream is broken.
+ */
+async function readSourceListAtTag(cwd, tag, path, verbose) {
+    let raw;
+    try {
+        const { stdout } = await execFileAsync('git', ['show', `${tag}:${path}`], { cwd, maxBuffer: 64 * 1024 * 1024 });
+        raw = stdout;
+    }
+    catch (error) {
+        await assertGitMeantAbsent(cwd, tag, path, error);
+        if (verbose)
+            console.log(`[gjsify flatpak sync-flathub] ${path} not present at ${tag} — skipping`);
+        return null;
+    }
+    if (raw.trim() === '') {
+        if (verbose)
+            console.log(`[gjsify flatpak sync-flathub] ${path} is empty at ${tag} — skipping`);
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`[gjsify flatpak sync-flathub] ${path} at ${tag} is not JSON: ` +
+            (error instanceof Error ? error.message : String(error)));
+    }
+    if (!Array.isArray(parsed) || parsed.length === 0) {
+        throw new Error(`[gjsify flatpak sync-flathub] ${path} at ${tag} is not a non-empty array of flatpak sources`);
+    }
+    return raw;
+}
+/**
+ * Throw unless a failed `git show <tag>:<path>` really did mean "that tag does
+ * not carry that file".
+ *
+ * MEASURED, and it is why the failure cannot be read on its own: path absent,
+ * unknown tag and not-a-git-repository are ALL exit 128, and git translates the
+ * message (`Pfad … existiert nicht in …` on a German host), so neither the
+ * status nor the text separates them. Taken for absence, a tag nobody fetched
+ * moves the pin and leaves the Flathub repo's old list in place — the failure
+ * this file exists to prevent, now silent. `--commit <sha>` is what puts it in
+ * reach: it is the one path on which nothing else resolves the tag.
+ *
+ * The tag is therefore asked about separately, and a SHA is believed rather
+ * than an exit code — the same lesson as the read above, since a `git` that
+ * answers 0 with nothing must not pass for a tag that exists.
+ */
+async function assertGitMeantAbsent(cwd, tag, path, error) {
+    const code = error?.code;
+    if (typeof code !== 'number') {
+        // Not git's verdict at all: ENOENT is no `git` on PATH, and
+        // ERR_CHILD_PROCESS_STDIO_MAXBUFFER a list past the cap set above.
+        throw new Error(`[gjsify flatpak sync-flathub] could not run \`git show ${tag}:${path}\` — ` +
+            (error instanceof Error ? error.message : String(error)));
+    }
+    // `--quiet` exits 1 rather than printing for a name it cannot resolve.
+    const sha = await execFileAsync('git', ['rev-parse', '--verify', '--quiet', `${tag}^{commit}`], { cwd })
+        .then(({ stdout }) => stdout.trim())
+        .catch(() => '');
+    if (!sha) {
+        throw new Error(`[gjsify flatpak sync-flathub] ${tag} does not resolve in ${cwd}, so whether it carries ${path} is unanswered. ` +
+            'Run `git fetch --tags`, pass --version <an existing tag>, or run from the app checkout.');
+    }
+}
 async function resolveLatestTag(cwd, verbose) {
     try {
         const { stdout } = await execFileAsync('git', ['describe', '--tags', '--abbrev=0'], { cwd });
@@ -258,14 +367,17 @@ export function editManifest(original, args) {
     if (sources.length === 0) {
         throw new Error('[gjsify flatpak sync-flathub] modules[0] has no sources');
     }
-    let idx = args.sourceIndex ?? sources.findIndex((s) => s.type === 'git');
+    const isObject = (s) => typeof s === 'object';
+    let idx = args.sourceIndex ?? sources.findIndex((s) => isObject(s) && s.type === 'git');
     if (idx < 0 || idx >= sources.length) {
         throw new Error(`[gjsify flatpak sync-flathub] no git source found in modules[0].sources (use --source-index <n>)`);
     }
-    const source = sources[idx];
-    if (source.type !== 'git') {
-        throw new Error(`[gjsify flatpak sync-flathub] modules[0].sources[${idx}].type is "${source.type}", expected "git"`);
+    const entry = sources[idx];
+    if (!isObject(entry) || entry.type !== 'git') {
+        const what = isObject(entry) ? `type is "${entry.type}"` : `is the file reference "${entry}"`;
+        throw new Error(`[gjsify flatpak sync-flathub] modules[0].sources[${idx}] ${what}, expected a git source`);
     }
+    const source = entry;
     source.tag = args.tag;
     source.commit = args.commit;
     if (!source['x-checker-data']) {
@@ -275,12 +387,42 @@ export function editManifest(original, args) {
             'version-scheme': 'semantic',
         };
     }
+    // THE OFFLINE TARBALL LIST, which is the half of a Flathub bump that is easy
+    // to forget because nothing points at it. Flathub builds with the network
+    // unshared, so an app whose install reads a generated source list cannot
+    // build from the git checkout alone; the list has to live in the Flathub repo
+    // and be named here. Repointing tag and commit alone produces a manifest that
+    // looks correct and cannot build, and the error it eventually gives is
+    // whatever the app's build system says when its install fails.
+    //
+    // Measured: Learn6502 0.8.0 was the first release after its vendored
+    // dependency cache was dropped, and its Flathub build died on exactly this.
+    if (args.sourcesFile && !namesFile(sources, args.sourcesFile)) {
+        sources.push(args.sourcesFile);
+    }
     // Detect the original indent (2 vs 4 spaces) by inspecting the second
     // line — Flathub manifests are all 2-space in practice, but some
     // older ones might be 4. Preserve original convention.
     const indent = detectIndent(original);
     return JSON.stringify(manifest, null, indent) + (original.endsWith('\n') ? '\n' : '');
 }
+/**
+ * Is `file` already among the module's bare-string sources?
+ *
+ * Compared with `./` stripped, because flatpak-builder resolves a string source
+ * against the manifest's own directory: `./gjsify-sources.json` and
+ * `gjsify-sources.json` are one file. Compared as written, a manifest holding
+ * the dotted spelling grows a second reference and the same tarballs are
+ * spliced in twice — the duplicate `dest`/`dest-filename` pairs `gjsify flatpak
+ * sources` dedupes its own output to avoid.
+ */
+function namesFile(sources, file) {
+    const want = stripDotSlash(file);
+    return sources.some((entry) => typeof entry === 'string' && stripDotSlash(entry) === want);
+}
+function stripDotSlash(ref) {
+    return ref.replace(/^\.\//, '');
+}
 function detectIndent(json) {
     const match = json.match(/^\{\n( +)/);
     if (match)

package/lib/commands/flatpak/utils.d.ts

@@ -1,3 +1,13 @@
+/**
+ * The generated offline tarball list, by the name both halves have to agree on.
+ *
+ * `gjsify flatpak sources` WRITES it; `gjsify flatpak sync-flathub` carries it
+ * into the Flathub repo and names it in the manifest. Each spelled the default
+ * itself, so changing one would have left the other reading a file nobody
+ * writes — and that shows up as a Flathub build which cannot install, four
+ * steps from its cause.
+ */
+export declare const FLATPAK_SOURCES_FILE = "gjsify-sources.json";
 /** Read package.json from a directory. Throws a helpful error if missing/invalid. */
 export declare function readPackageJson(dir: string): Record<string, unknown>;
 /** True if a name string looks like a reverse-DNS Flatpak app id. */

package/lib/commands/flatpak/utils.js

@@ -5,6 +5,16 @@
 // header. What is left here is what only these subcommands ask.
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
+/**
+ * The generated offline tarball list, by the name both halves have to agree on.
+ *
+ * `gjsify flatpak sources` WRITES it; `gjsify flatpak sync-flathub` carries it
+ * into the Flathub repo and names it in the manifest. Each spelled the default
+ * itself, so changing one would have left the other reading a file nobody
+ * writes — and that shows up as a Flathub build which cannot install, four
+ * steps from its cause.
+ */
+export const FLATPAK_SOURCES_FILE = 'gjsify-sources.json';
 /** Read package.json from a directory. Throws a helpful error if missing/invalid. */
 export function readPackageJson(dir) {
     const path = resolve(dir, 'package.json');

package/lib/commands/foreach.js

@@ -9,7 +9,7 @@
 // matching yarn's interactive flow. Exit code is non-zero if any child
 // process failed; first failure's stderr is forwarded.
 import { spawnToCompletion } from '../utils/spawn.js';
-import { readFileSync, readdirSync } from 'node:fs';
+import { collectDescendants } from '../utils/process-table.js';
 import { cpus } from 'node:os';
 import { affectedClosure, buildDependencyGraph, discoverWorkspaces, filterWorkspaces, topologicalSort, } from '@gjsify/workspace';
 import { findWorkspaceRoot } from '../utils/workspace-root.js';
@@ -34,101 +34,6 @@ const KILL_GRACE_MS = 5_000;
 // killed child whose grandchildren inherit (and keep open) the stdio pipe
 // never emits 'close', so we must not wait on it unboundedly.
 const DRAIN_DEADLINE_MS = 15_000;
-// Read the direct child PIDs of `pid` from /proc/<pid>/task/*/children
-// (Linux, CONFIG_PROC_CHILDREN — standard on every mainstream kernel). When
-// the per-task children files are unavailable, fall back to one full
-// /proc/*/stat scan building a ppid→children map. Both paths use only
-// `node:fs` reads, so they behave identically under Node and GJS
-// (@gjsify/fs) — unlike a process-group kill, which GJS cannot issue
-// (`@gjsify/process.kill` shells out `kill <sig> <pid>` where a negative
-// PID parses as an option, and Gio.Subprocess has no group-signal API).
-function readDirectChildren(pid) {
-    let taskIds;
-    try {
-        taskIds = readdirSync(`/proc/${pid}/task`);
-    }
-    catch {
-        // Process already gone (common) or /proc unavailable.
-        return null;
-    }
-    const kids = [];
-    let readAny = false;
-    for (const tid of taskIds) {
-        try {
-            const data = readFileSync(`/proc/${pid}/task/${tid}/children`, 'utf-8');
-            readAny = true;
-            for (const tok of data.trim().split(/\s+/)) {
-                const n = Number(tok);
-                if (Number.isInteger(n) && n > 0)
-                    kids.push(n);
-            }
-        }
-        catch {
-            // Thread vanished mid-walk, or kernel lacks CONFIG_PROC_CHILDREN.
-        }
-    }
-    return readAny ? kids : null;
-}
-// Fallback: scan every /proc/<pid>/stat once and build ppid → children.
-// O(#processes) small reads — fine for the rare kill path.
-function buildPpidMap() {
-    const map = new Map();
-    let entries = [];
-    try {
-        entries = readdirSync('/proc');
-    }
-    catch {
-        return map;
-    }
-    for (const entry of entries) {
-        const pid = Number(entry);
-        if (!Number.isInteger(pid) || pid <= 0)
-            continue;
-        try {
-            const stat = readFileSync(`/proc/${pid}/stat`, 'utf-8');
-            // comm (field 2) may contain spaces/parens — parse after last ')'.
-            const rest = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
-            const ppid = Number(rest[1]);
-            if (!Number.isInteger(ppid) || ppid <= 0)
-                continue;
-            const siblings = map.get(ppid);
-            if (siblings)
-                siblings.push(pid);
-            else
-                map.set(ppid, [pid]);
-        }
-        catch {
-            // Process exited between readdir and read — fine.
-        }
-    }
-    return map;
-}
-// Snapshot every transitive descendant of `pid`, breadth-first (so
-// reversing the list yields deepest-first order for signalling).
-function collectDescendants(pid) {
-    const result = [];
-    const seen = new Set([pid]);
-    const queue = [pid];
-    let ppidMap = null;
-    while (queue.length > 0) {
-        const cur = queue.shift();
-        let kids = readDirectChildren(cur);
-        if (kids === null) {
-            // children files unreadable — use (and lazily build) the
-            // full-scan fallback for this and subsequent levels.
-            ppidMap ??= buildPpidMap();
-            kids = ppidMap.get(cur) ?? [];
-        }
-        for (const kid of kids) {
-            if (seen.has(kid))
-                continue;
-            seen.add(kid);
-            result.push(kid);
-            queue.push(kid);
-        }
-    }
-    return result;
-}
 // Signal an already-collected descendant set deepest-first, then the direct
 // child itself. Snapshot-then-signal (not signal-while-walking) so killing
 // the parent can't orphan grandchildren before we enumerated them. The
@@ -157,7 +62,10 @@ function killActiveChildren() {
     // The direct child is `npm run <script>` — killing only it leaves the
     // npm-spawned shell → gjs/node build grandchildren alive (observed: an
     // orphaned gjs bundler at 100% CPU for 19+ min after a fail-fast kill).
-    // So terminate the whole process TREE of each child via a /proc walk.
+    // So terminate the whole process TREE of each child — walked by
+    // `utils/process-table.ts` (procfs on Linux, the OS process list elsewhere).
+    // A process-group kill would be simpler and GJS cannot issue one:
+    // Gio.Subprocess has no group-signal API.
     const termSnapshots = new Map();
     for (const child of activeChildren) {
         const descendants = child.pid ? collectDescendants(child.pid) : [];

package/lib/commands/format.js

@@ -7,9 +7,10 @@
 // optionalDependency, keeping the Node-free runtime promise for the bundled
 // CLI intact (the formatter runs in dev/CI, not in shipped GJS apps).
 //
-// oxfmt formats JS/TS (+TOML) only. CSS/JSON formatting that the old Biome
-// toolchain handled is intentionally DROPPED in the oxc migration — no other
-// formatter is wired up for those file types.
+// oxfmt formats JS/TS, JSON, TOML, CSS and GraphQL in both builds; the
+// languages it hands to its Prettier host (Markdown, HTML, Vue, YAML, …) are
+// napi-only — the native GJS build drops them, which the skip scan below
+// reports.
 //
 // A BARE `gjsify format` WRITES. `--check` is the read-only CI mode and
 // `--no-write` the read-only local one; there is no flagless report mode.
@@ -24,11 +25,12 @@
 // tuned for GJS/GNOME projects (4-space, single-quote, printWidth 120,
 // trailing-comma all, semicolons always, arrow parens always).
 import { existsSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { OxcNotFoundError, findOxfmtConfig, loadOxfmtTemplate, loadOxlintTemplate, printOxcNotFound, runOxfmt, setOxcExitCode, } from '../utils/oxc-resolve.js';
+import { relative, resolve } from 'node:path';
+import { OxcNotFoundError, findOxfmtConfig, loadOxfmtTemplate, loadOxlintTemplate, printOxcNotFound, runOxfmt, setOxcExitCode, shouldUseNativeOxfmt, } from '../utils/oxc-resolve.js';
+import { scanForNativeSkips } from '../utils/native-skip-scan.js';
 export const formatCommand = {
     command: 'format [paths..]',
-    description: 'Format JS/TS source files via oxfmt (CSS/JSON formatting is not supported).',
+    description: 'Format source files via oxfmt (Markdown/YAML/HTML/Vue need the napi build).',
     builder: (yargs) => {
         return yargs
             .positional('paths', {
@@ -90,6 +92,24 @@ export const formatCommand = {
         if (configPath)
             oxfmtArgs.push('--config', resolve(configPath));
         oxfmtArgs.push(...paths);
+        // Under GJS the native oxfmt formats everything but the files napi oxfmt
+        // hands to its Prettier host (Markdown, HTML, Vue, YAML, …), and it drops
+        // those without a word. `--check` FAILS on them, so a green check that
+        // checked nothing is impossible — asked about exactly the files oxfmt
+        // itself would walk with this config, never `node_modules` or ignored ones.
+        if (args.check && (await shouldUseNativeOxfmt())) {
+            const scan = scanForNativeSkips(paths, cwd, { configPath });
+            if (scan.skipped.length > 0) {
+                const list = scan.skipped.map((f) => `  ${relative(cwd, f) || f}`).join('\n');
+                console.error(`[gjsify format] ERROR: ${scan.skipped.length} file(s) skipped — ` +
+                    `the native oxfmt (GJS) has no Prettier host for them (Markdown/HTML/Vue/YAML/…):\n` +
+                    `${list}\n` +
+                    `  The format check is INCOMPLETE. Run \`gjsify format --check\` under Node to check these ` +
+                    `files, or add them to \`ignorePatterns\`.`);
+                setOxcExitCode(1);
+                return;
+            }
+        }
         try {
             const code = await runOxfmt(oxfmtArgs, { cwd, verbose: args.verbose });
             setOxcExitCode(code);

package/lib/commands/index.d.ts

@@ -1,6 +1,8 @@
 export * from './build.js';
 export * from './clear.js';
 export * from './copy.js';
+export * from './env.js';
+export * from './exec.js';
 export * from './test.js';
 export * from './run.js';
 export * from './info.js';
@@ -15,6 +17,7 @@ export { flatpakCommand } from './flatpak/index.js';
 export * from './ship.js';
 export * from './dlx.js';
 export * from './install.js';
+export * from './link.js';
 export * from './foreach.js';
 export * from './workspace.js';
 export * from './pack.js';
@@ -39,3 +42,4 @@ export * from './storybook.js';
 export * from './dev.js';
 export * from './debug.js';
 export * from './browse.js';
+export { webextCommand } from './webext/index.js';

package/lib/commands/index.js

@@ -1,6 +1,8 @@
 export * from './build.js';
 export * from './clear.js';
 export * from './copy.js';
+export * from './env.js';
+export * from './exec.js';
 export * from './test.js';
 export * from './run.js';
 export * from './info.js';
@@ -15,6 +17,7 @@ export { flatpakCommand } from './flatpak/index.js';
 export * from './ship.js';
 export * from './dlx.js';
 export * from './install.js';
+export * from './link.js';
 export * from './foreach.js';
 export * from './workspace.js';
 export * from './pack.js';
@@ -39,3 +42,4 @@ export * from './storybook.js';
 export * from './dev.js';
 export * from './debug.js';
 export * from './browse.js';
+export { webextCommand } from './webext/index.js';

package/lib/commands/install.d.ts

@@ -83,8 +83,8 @@ export interface EnsureProjectGjsEngineDeps {
  *
  * The engine is an OPTIONAL PEER of `@gjsify/cli` on purpose — a plain
  * `npm install @gjsify/cli` on Node must not fetch prebuilds — but nobody resolves
- * it for a project: npm 7+ skips optional peers and the native backend does not
- * resolve `peerDependencies` at all. Under GJS there is no npm `rolldown`
+ * it for a project: npm 7+ skips optional peers and so does the native backend
+ * (it installs REQUIRED peers only). Under GJS there is no npm `rolldown`
  * fallback, so `gjsify build` had nothing to load.
  *
  * Four conditions, and (b) is the one worth reading: