@gjsify/cli 0.3.14 → 0.3.16

package/lib/actions/build.d.ts

@@ -26,8 +26,12 @@ export declare class BuildAction {
      */
     private resolveGlobalsInject;
     /**
-     * Post-processing: prepend GJS shebang and mark the output file executable.
-     * Only runs for GJS app builds with a resolvable single outfile.
+     * Post-processing: prepend the resolved shebang line and mark the
+     * output executable. Only runs for GJS app builds with a single outfile.
+     * The shebang plugin in `@gjsify/rolldown-plugin-gjsify` already injects
+     * during bundling — this hook is the safety net for anything that
+     * bypassed the plugin (e.g. user-supplied banners that out-ordered it),
+     * plus the chmod.
      */
     private applyShebang;
     /** Application mode */

package/lib/actions/build.js

@@ -1,11 +1,12 @@
 import { rolldown } from "rolldown";
-import { gjsifyPlugin } from "@gjsify/rolldown-plugin-gjsify";
+import { gjsifyPlugin, textLoaderPlugin, resolveShebangLine } from "@gjsify/rolldown-plugin-gjsify";
+import { resolveUserPlugins } from "../utils/resolve-plugin-by-name.js";
 import { resolveGlobalsList, writeRegisterInjectFile, detectAutoGlobals, } from "@gjsify/rolldown-plugin-gjsify/globals";
 import { pnpPlugin } from "@gjsify/rolldown-plugin-pnp";
 import { dirname, extname } from "node:path";
 import { chmod, readFile, writeFile } from "node:fs/promises";
 import { normalizeBundlerOptions, mergeBundlerOptions } from "../utils/normalize-bundler-options.js";
-const GJS_SHEBANG = "#!/usr/bin/env -S gjs -m\n";
+const DEFAULT_GJS_SHEBANG = "#!/usr/bin/env -S gjs -m";
 /**
  * `true` when `path` points at a location that's unsafe to use as a build
  * outfile (would overwrite source). Currently catches:
@@ -150,8 +151,12 @@ export class BuildAction {
         return injectPath ?? undefined;
     }
     /**
-     * Post-processing: prepend GJS shebang and mark the output file executable.
-     * Only runs for GJS app builds with a resolvable single outfile.
+     * Post-processing: prepend the resolved shebang line and mark the
+     * output executable. Only runs for GJS app builds with a single outfile.
+     * The shebang plugin in `@gjsify/rolldown-plugin-gjsify` already injects
+     * during bundling — this hook is the safety net for anything that
+     * bypassed the plugin (e.g. user-supplied banners that out-ordered it),
+     * plus the chmod.
      */
     async applyShebang(outfile, verbose) {
         if (!outfile) {
@@ -159,17 +164,18 @@ export class BuildAction {
                 console.warn("[gjsify] --shebang skipped: no single outfile (use --outfile for GJS executables)");
             return;
         }
+        const line = resolveShebangLine(this.configData.shebang) ?? DEFAULT_GJS_SHEBANG;
         const content = await readFile(outfile, "utf-8");
         if (content.startsWith("#!")) {
             if (verbose)
                 console.debug(`[gjsify] --shebang skipped: ${outfile} already starts with a shebang`);
         }
         else {
-            await writeFile(outfile, GJS_SHEBANG + content);
+            await writeFile(outfile, line + "\n" + content);
         }
         await chmod(outfile, 0o755);
         if (verbose)
-            console.debug(`[gjsify] --shebang: wrote shebang + chmod 0o755 to ${outfile}`);
+            console.debug(`[gjsify] --shebang: wrote ${line} + chmod 0o755 to ${outfile}`);
     }
     /** Application mode */
     async buildApp(app = "gjs") {
@@ -213,6 +219,24 @@ export class BuildAction {
         const { autoMode, extras } = this.parseGlobalsValue(globals);
         const pnp = await buildPnpPlugin();
         const pnpPlugins = pnp ? [pnp] : [];
+        // User-supplied text loaders need to be available during BOTH the
+        // auto-globals pre-build (`detectAutoGlobals`) and the final build —
+        // otherwise Rolldown's parser hits unknown extensions like `.ui` /
+        // `.asm` during the pre-build, fails to parse them as JS/JSX, and
+        // the auto-globals iteration aborts before the final plugin chain is
+        // ever assembled. Build the user-plugin chain once, up front, and
+        // pass it into both passes.
+        const userTextLoader = textLoaderPlugin({ loaders: this.configData.loaders });
+        const userPlugins = userTextLoader ? [userTextLoader] : [];
+        // User-supplied bundler.plugins (mix of plugin objects + by-name
+        // entries) — resolved from the project's node_modules. Same
+        // ordering rationale as the text loader: must be present during
+        // auto-globals pre-build to avoid claiming the same files via
+        // Rolldown's default classifier.
+        if (userBundler.plugins?.length) {
+            const resolved = await resolveUserPlugins(userBundler.plugins, process.cwd());
+            userPlugins.push(...resolved);
+        }
         // --- Auto mode (with optional extras): iterative multi-pass build ---
         if (app === "gjs" && autoMode) {
             const gjsifyPluginFactory = async (opts) => {
@@ -228,7 +252,7 @@ export class BuildAction {
             };
             const { injectPath } = await detectAutoGlobals({
                 input: userBundler.input,
-                plugins: pnpPlugins,
+                plugins: [...pnpPlugins, ...userPlugins],
                 external: userBundler.external,
                 transform: userBundler.transform,
                 format,
@@ -250,7 +274,12 @@ export class BuildAction {
         const merged = mergeBundlerOptions(cfg.options, userBundler);
         const finalOpts = {
             ...merged,
-            plugins: [...pnpPlugins, ...cfg.plugins],
+            // Drop user-config plugins from `merged` — they survived
+            // mergeBundlerOptions via spread but have already been resolved
+            // and appended into `userPlugins` above. Re-emitting the raw
+            // entries (which may include `BundlerPluginByName` shapes
+            // Rolldown doesn't understand) would crash the build.
+            plugins: [...pnpPlugins, ...userPlugins, ...cfg.plugins],
         };
         const build = await rolldown(finalOpts);
         let writeResult;

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

@@ -0,0 +1,16 @@
+import type { Command } from '../../types/index.js';
+interface FlatpakBuildOptions {
+    manifest?: string;
+    buildDir?: string;
+    install?: boolean;
+    repo?: string;
+    bundle?: string;
+    tarball?: string;
+    forceClean?: boolean;
+    sandbox?: boolean;
+    deleteBuildDirs?: boolean;
+    installDepsFrom?: string;
+    verbose?: boolean;
+}
+export declare const flatpakBuildCommand: Command<unknown, FlatpakBuildOptions>;
+export {};

package/lib/commands/flatpak/build.js

@@ -0,0 +1,187 @@
+// `gjsify flatpak build` — wrap `flatpak-builder` with sensible defaults.
+//
+// Replaces the project-local `build-flatpak.sh`-style scripts: same flag
+// shape (manifest, build-dir, install, repo, bundle), plus a `--tarball`
+// helper for Flathub submissions.
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+export const flatpakBuildCommand = {
+    command: 'build [manifest]',
+    description: 'Build the Flatpak via `flatpak-builder`. Wraps a typical install + export + bundle + tarball pipeline.',
+    builder: (yargs) => {
+        return yargs
+            .positional('manifest', {
+            description: 'Path to the Flatpak manifest (default: first *.json that looks like a manifest in cwd)',
+            type: 'string',
+            normalize: true,
+        })
+            .option('build-dir', {
+            description: 'flatpak-builder working directory',
+            type: 'string',
+            default: 'flatpak-build',
+            normalize: true,
+        })
+            .option('install', {
+            description: 'After build, run `flatpak-builder --user --install` to install locally',
+            type: 'boolean',
+            default: false,
+        })
+            .option('repo', {
+            description: 'Export the build into the given OSTree repo (passes `--repo=<dir>` to flatpak-builder)',
+            type: 'string',
+            normalize: true,
+        })
+            .option('bundle', {
+            description: 'After --repo export, build a single-file bundle (`flatpak build-bundle`) at this path',
+            type: 'string',
+            normalize: true,
+        })
+            .option('tarball', {
+            description: 'Create a tarball of the build dir (parity with the legacy build-flatpak.sh tarball step)',
+            type: 'string',
+            normalize: true,
+        })
+            .option('force-clean', {
+            description: 'Pass --force-clean to flatpak-builder (default true)',
+            type: 'boolean',
+            default: true,
+        })
+            .option('sandbox', {
+            description: 'Pass --sandbox to flatpak-builder (default true)',
+            type: 'boolean',
+            default: true,
+        })
+            .option('delete-build-dirs', {
+            description: 'Pass --delete-build-dirs to flatpak-builder (default true)',
+            type: 'boolean',
+            default: true,
+        })
+            .option('install-deps-from', {
+            description: 'Pass --install-deps-from to flatpak-builder (e.g. `flathub`)',
+            type: 'string',
+        })
+            .option('verbose', {
+            description: 'Print the underlying flatpak-builder invocations',
+            type: 'boolean',
+            default: false,
+        });
+    },
+    handler: async (args) => {
+        const cwd = process.cwd();
+        const manifest = resolve(cwd, args.manifest ?? findDefaultManifest(cwd));
+        if (!existsSync(manifest)) {
+            throw new Error(`gjsify flatpak build: manifest ${manifest} not found`);
+        }
+        const buildDir = resolve(cwd, args.buildDir ?? 'flatpak-build');
+        const sharedFlags = [];
+        if (args.forceClean !== false)
+            sharedFlags.push('--force-clean');
+        if (args.sandbox !== false)
+            sharedFlags.push('--sandbox');
+        if (args.deleteBuildDirs !== false)
+            sharedFlags.push('--delete-build-dirs');
+        if (args.installDepsFrom)
+            sharedFlags.push(`--install-deps-from=${args.installDepsFrom}`);
+        // Reset the build dir so re-runs don't pick up half-stale state.
+        if (existsSync(buildDir))
+            rmSync(buildDir, { recursive: true, force: true });
+        await runFlatpakBuilder([...sharedFlags, buildDir, manifest], { verbose: args.verbose });
+        if (args.install) {
+            await runFlatpakBuilder(['--user', '--install', '--force-clean', buildDir, manifest], { verbose: args.verbose });
+        }
+        if (args.repo) {
+            const repoPath = resolve(cwd, args.repo);
+            mkdirSync(dirname(repoPath), { recursive: true });
+            await runFlatpakBuilder([`--repo=${repoPath}`, '--force-clean', buildDir, manifest], { verbose: args.verbose });
+        }
+        if (args.bundle) {
+            if (!args.repo) {
+                throw new Error('gjsify flatpak build: --bundle requires --repo (the bundle is built from the OSTree repo).');
+            }
+            const bundlePath = resolve(cwd, args.bundle);
+            mkdirSync(dirname(bundlePath), { recursive: true });
+            const repoPath = resolve(cwd, args.repo);
+            const appId = readManifestAppId(manifest);
+            await runFlatpak(['build-bundle', repoPath, bundlePath, appId], { verbose: args.verbose });
+        }
+        if (args.tarball) {
+            const tarballPath = resolve(cwd, args.tarball);
+            mkdirSync(dirname(tarballPath), { recursive: true });
+            await runTar(['-czf', tarballPath, '-C', buildDir, '.'], { verbose: args.verbose });
+        }
+        console.log(`[gjsify flatpak build] done (${buildDir})`);
+    },
+};
+/** Pick the first JSON file in cwd that looks like a Flatpak manifest. */
+function findDefaultManifest(cwd) {
+    return scanForManifest(cwd) ?? 'flatpak.json';
+}
+function scanForManifest(cwd) {
+    let entries = [];
+    try {
+        entries = readdirSync(cwd);
+    }
+    catch {
+        return undefined;
+    }
+    for (const name of entries) {
+        if (!name.endsWith('.json'))
+            continue;
+        if (name === 'package.json' || name === 'tsconfig.json' || name.startsWith('.'))
+            continue;
+        try {
+            const json = JSON.parse(readFileSync(resolve(cwd, name), 'utf-8'));
+            if (typeof json.id === 'string' && typeof json.runtime === 'string' && Array.isArray(json.modules)) {
+                return name;
+            }
+        }
+        catch {
+            // Not JSON or unreadable — skip.
+        }
+    }
+    return undefined;
+}
+function readManifestAppId(manifest) {
+    const raw = readFileSync(manifest, 'utf-8');
+    const json = JSON.parse(raw);
+    if (typeof json.id !== 'string') {
+        throw new Error(`gjsify flatpak build: ${manifest} has no string "id" field`);
+    }
+    return json.id;
+}
+async function runFlatpakBuilder(args, opts) {
+    return runProc('flatpak-builder', args, opts, {
+        notFoundHint: 'flatpak-builder not found. Install via your distro (Fedora: `sudo dnf install flatpak-builder`).',
+    });
+}
+async function runFlatpak(args, opts) {
+    return runProc('flatpak', args, opts, {
+        notFoundHint: 'flatpak not found. Install via your distro and add Flathub: see https://flathub.org/setup.',
+    });
+}
+async function runTar(args, opts) {
+    return runProc('tar', args, opts, { notFoundHint: 'tar not found.' });
+}
+function runProc(cmd, args, opts, extra) {
+    if (opts.verbose) {
+        console.log(`[gjsify flatpak] ${cmd} ${args.join(' ')}`);
+    }
+    return new Promise((res, rej) => {
+        const child = spawn(cmd, args, { stdio: 'inherit' });
+        child.on('error', (err) => {
+            if (err.code === 'ENOENT') {
+                rej(new Error(`gjsify flatpak: ${extra.notFoundHint}`));
+            }
+            else {
+                rej(err);
+            }
+        });
+        child.on('exit', (code) => {
+            if (code === 0)
+                res();
+            else
+                rej(new Error(`gjsify flatpak: ${cmd} exited with status ${code}`));
+        });
+    });
+}

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

@@ -0,0 +1,13 @@
+import type { Command } from '../../types/index.js';
+interface FlatpakCiOptions {
+    manifest?: string;
+    bundle?: string;
+    runtimeImage?: string;
+    branches?: string[];
+    out?: string;
+    force?: boolean;
+    cacheKey?: string;
+    verbose?: boolean;
+}
+export declare const flatpakCiCommand: Command<unknown, FlatpakCiOptions>;
+export {};

package/lib/commands/flatpak/ci.js

@@ -0,0 +1,133 @@
+// `gjsify flatpak ci` — scaffold .github/workflows/flatpak.yml in the
+// shape used by Flathub-hosted apps:
+//
+//   * upstream `flatpak/flatpak-github-actions/flatpak-builder@v6` action
+//   * `ghcr.io/flathub-infra/flatpak-github-actions:<runtime>-<version>` container
+//   * cache key keyed by commit SHA
+//
+// Idempotent: refuses to overwrite an existing workflow without `--force`.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { Config } from '../../config.js';
+import { defaultCiContainer, looksLikeAppId, readPackageJson, resolveRuntime } from './utils.js';
+export const flatpakCiCommand = {
+    command: 'ci',
+    description: 'Scaffold .github/workflows/flatpak.yml using the flathub-infra container + flatpak-builder@v6 action.',
+    builder: (yargs) => {
+        return yargs
+            .option('manifest', {
+            description: 'Manifest path the workflow points at (default: <app-id>.json)',
+            type: 'string',
+            normalize: true,
+        })
+            .option('bundle', {
+            description: 'Bundle filename produced by the action (default: <app-id>.flatpak)',
+            type: 'string',
+            normalize: true,
+        })
+            .option('runtime-image', {
+            description: 'Container image override. Default derived from gjsify.flatpak.runtime + runtimeVersion (e.g. `ghcr.io/flathub-infra/flatpak-github-actions:gnome-50`).',
+            type: 'string',
+        })
+            .option('branches', {
+            description: 'Branches the workflow runs on push for (default: main)',
+            type: 'string',
+            array: true,
+        })
+            .option('out', {
+            description: 'Output path',
+            type: 'string',
+            default: '.github/workflows/flatpak.yml',
+            normalize: true,
+        })
+            .option('cache-key', {
+            description: 'Override the action `cache-key` (default: `flatpak-builder-${{ github.sha }}`)',
+            type: 'string',
+        })
+            .option('force', {
+            description: 'Overwrite an existing workflow file',
+            type: 'boolean',
+            default: false,
+        })
+            .option('verbose', {
+            description: 'Print resolved fields',
+            type: 'boolean',
+            default: false,
+        });
+    },
+    handler: async (args) => {
+        const cwd = process.cwd();
+        const cfg = new Config();
+        const configData = await cfg.forBuild({}).catch(() => ({}));
+        const flatpak = configData.flatpak ?? {};
+        const pkg = readPackageJson(cwd);
+        const appId = flatpak.appId ??
+            (looksLikeAppId(pkg.name) ? pkg.name : undefined);
+        if (!appId) {
+            throw new Error('gjsify flatpak ci: no app id available. Set gjsify.flatpak.appId in package.json ' +
+                'or rename the package to a reverse-DNS id.');
+        }
+        const manifest = args.manifest ?? `${appId}.json`;
+        const bundle = args.bundle ?? `${appId}.flatpak`;
+        const { runtime, runtimeVersion } = resolveRuntime(flatpak, {});
+        const runtimeImage = args.runtimeImage ??
+            flatpak.ciContainer ??
+            defaultCiContainer(runtime, runtimeVersion);
+        const branches = args.branches ?? flatpak.ciBranches ?? ['main'];
+        const cacheKey = args.cacheKey ?? 'flatpak-builder-${{ github.sha }}';
+        const out = resolve(cwd, args.out ?? '.github/workflows/flatpak.yml');
+        if (existsSync(out) && !args.force) {
+            // Same content → silently skip; different content → fail with a hint.
+            const existing = readFileSync(out, 'utf-8');
+            const next = renderWorkflow({ manifest, bundle, runtimeImage, branches, cacheKey });
+            if (existing === next) {
+                console.log(`[gjsify flatpak ci] ${out} already up to date`);
+                return;
+            }
+            throw new Error(`gjsify flatpak ci: ${out} exists with different content. Pass --force to overwrite.`);
+        }
+        const content = renderWorkflow({ manifest, bundle, runtimeImage, branches, cacheKey });
+        mkdirSync(dirname(out), { recursive: true });
+        writeFileSync(out, content, 'utf-8');
+        if (args.verbose) {
+            console.log(`[gjsify flatpak ci] runtime-image=${runtimeImage} manifest=${manifest} bundle=${bundle}`);
+        }
+        console.log(`[gjsify flatpak ci] wrote ${out}`);
+    },
+};
+/**
+ * Render the workflow YAML. Format string built explicitly (no template
+ * library) so the output is byte-stable for diff-based code review.
+ */
+function renderWorkflow(input) {
+    const branchesYaml = `[${input.branches.map((b) => JSON.stringify(b)).join(', ')}]`;
+    return `name: Flatpak
+
+on:
+  push:
+    branches: ${branchesYaml}
+  pull_request:
+    branches: ${branchesYaml}
+
+jobs:
+  flatpak:
+    name: Flatpak Build
+    runs-on: ubuntu-latest
+    container:
+      image: ${input.runtimeImage}
+      options: --privileged
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          submodules: false
+
+      - name: Build Flatpak
+        uses: flatpak/flatpak-github-actions/flatpak-builder@v6
+        with:
+          manifest-path: ${input.manifest}
+          bundle: ${input.bundle}
+          cache-key: ${input.cacheKey}
+`;
+}

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

@@ -0,0 +1,12 @@
+import type { Command } from '../../types/index.js';
+interface FlatpakDepsOptions {
+    lockfile?: string;
+    type?: 'yarn' | 'npm';
+    out?: string;
+    xdgLayout?: boolean;
+    nodeChromedriverFromElectron?: string;
+    electronNodeHeaders?: boolean;
+    verbose?: boolean;
+}
+export declare const flatpakDepsCommand: Command<unknown, FlatpakDepsOptions>;
+export {};

package/lib/commands/flatpak/deps.js

@@ -0,0 +1,96 @@
+// `gjsify flatpak deps` — wrap `flatpak-node-generator` to convert a
+// yarn.lock / package-lock.json into the JSON sources file that the
+// Flatpak manifest references for offline `yarn install` inside the
+// build sandbox.
+//
+// flatpak-node-generator is a Python tool from
+// https://github.com/flatpak/flatpak-builder-tools — installed via
+// `pipx install flatpak-node-generator` or `pip install --user
+// flatpak-node-generator`.
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { mkdirSync } from 'node:fs';
+export const flatpakDepsCommand = {
+    command: 'deps',
+    description: 'Generate Flatpak offline-cache sources from a yarn.lock / package-lock.json (wraps `flatpak-node-generator`).',
+    builder: (yargs) => {
+        return yargs
+            .option('lockfile', {
+            description: 'Path to lockfile (default: yarn.lock or package-lock.json in cwd)',
+            type: 'string',
+            normalize: true,
+        })
+            .option('type', {
+            description: 'Lockfile type. Default: detected from filename.',
+            choices: ['yarn', 'npm'],
+        })
+            .option('out', {
+            description: 'Output JSON sources file',
+            type: 'string',
+            default: 'flatpak-node-sources.json',
+            normalize: true,
+        })
+            .option('xdg-layout', {
+            description: 'Pass --xdg-layout (recommended for Yarn Berry / PnP setups)',
+            type: 'boolean',
+            default: true,
+        })
+            .option('electron-node-headers', {
+            description: 'Pass --electron-node-headers',
+            type: 'boolean',
+            default: false,
+        })
+            .option('verbose', {
+            description: 'Print the underlying flatpak-node-generator invocation',
+            type: 'boolean',
+            default: false,
+        });
+    },
+    handler: async (args) => {
+        const cwd = process.cwd();
+        const lockfile = resolve(cwd, args.lockfile ?? detectLockfile(cwd));
+        if (!existsSync(lockfile)) {
+            throw new Error(`gjsify flatpak deps: lockfile ${lockfile} not found (use --lockfile to override)`);
+        }
+        const type = args.type ??
+            (lockfile.endsWith('package-lock.json') ? 'npm' : 'yarn');
+        const out = resolve(cwd, args.out ?? 'flatpak-node-sources.json');
+        mkdirSync(dirname(out), { recursive: true });
+        const cmdArgs = [type, lockfile, '-o', out];
+        if (args.xdgLayout !== false)
+            cmdArgs.push('--xdg-layout');
+        if (args.electronNodeHeaders)
+            cmdArgs.push('--electron-node-headers');
+        if (args.verbose) {
+            console.log(`[gjsify flatpak deps] flatpak-node-generator ${cmdArgs.join(' ')}`);
+        }
+        await new Promise((res, rej) => {
+            const child = spawn('flatpak-node-generator', cmdArgs, { stdio: 'inherit' });
+            child.on('error', (err) => {
+                if (err.code === 'ENOENT') {
+                    rej(new Error('gjsify flatpak deps: flatpak-node-generator not found. ' +
+                        'Install via `pipx install flatpak-node-generator` ' +
+                        '(see https://github.com/flatpak/flatpak-builder-tools/tree/master/node).'));
+                }
+                else {
+                    rej(err);
+                }
+            });
+            child.on('exit', (code) => {
+                if (code === 0)
+                    res();
+                else
+                    rej(new Error(`gjsify flatpak deps: flatpak-node-generator exited with status ${code}`));
+            });
+        });
+        console.log(`[gjsify flatpak deps] wrote ${out}`);
+    },
+};
+function detectLockfile(cwd) {
+    if (existsSync(resolve(cwd, 'yarn.lock')))
+        return 'yarn.lock';
+    if (existsSync(resolve(cwd, 'package-lock.json')))
+        return 'package-lock.json';
+    return 'yarn.lock'; // surfaces a clear "not found" later
+}

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

@@ -0,0 +1,7 @@
+import type { Command } from '../../types/index.js';
+import { flatpakInitCommand } from './init.js';
+import { flatpakBuildCommand } from './build.js';
+import { flatpakDepsCommand } from './deps.js';
+import { flatpakCiCommand } from './ci.js';
+export declare const flatpakCommand: Command;
+export { flatpakInitCommand, flatpakBuildCommand, flatpakDepsCommand, flatpakCiCommand, };

package/lib/commands/flatpak/index.js

@@ -0,0 +1,23 @@
+// `gjsify flatpak` — yargs subcommand-group dispatcher.
+//
+// Wires {init, build, deps, ci}. Each subcommand is a self-contained
+// `Command<>` so it composes the same way as `gresource` / `gettext` /
+// `gsettings` at the top level.
+import { flatpakInitCommand } from './init.js';
+import { flatpakBuildCommand } from './build.js';
+import { flatpakDepsCommand } from './deps.js';
+import { flatpakCiCommand } from './ci.js';
+export const flatpakCommand = {
+    command: 'flatpak <subcommand>',
+    description: 'Flatpak toolchain: init/build/deps/ci subcommands for shipping GJS apps and CLIs as Flatpaks.',
+    builder: (yargs) => {
+        return yargs
+            .command(flatpakInitCommand.command, flatpakInitCommand.description, flatpakInitCommand.builder, flatpakInitCommand.handler)
+            .command(flatpakBuildCommand.command, flatpakBuildCommand.description, flatpakBuildCommand.builder, flatpakBuildCommand.handler)
+            .command(flatpakDepsCommand.command, flatpakDepsCommand.description, flatpakDepsCommand.builder, flatpakDepsCommand.handler)
+            .command(flatpakCiCommand.command, flatpakCiCommand.description, flatpakCiCommand.builder, flatpakCiCommand.handler)
+            .demandCommand(1)
+            .strict();
+    },
+};
+export { flatpakInitCommand, flatpakBuildCommand, flatpakDepsCommand, flatpakCiCommand, };

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

@@ -0,0 +1,15 @@
+import type { Command } from '../../types/index.js';
+interface FlatpakInitOptions {
+    appId?: string;
+    runtime?: string;
+    runtimeVersion?: string;
+    cliOnly?: boolean;
+    manifest?: string;
+    command?: string;
+    force?: boolean;
+    sdkExtension?: string[];
+    finishArg?: string[];
+    verbose?: boolean;
+}
+export declare const flatpakInitCommand: Command<unknown, FlatpakInitOptions>;
+export {};