@gjsify/cli 0.3.21 → 0.4.3

package/src/commands/create.ts

@@ -1,63 +0,0 @@
-import { createProject, discoverTemplates } from '@gjsify/create-app';
-import { promptTemplate } from '@gjsify/create-app/prompt';
-import type { Command } from '../types/index.js';
-
-interface CreateOptions {
-    'project-name': string;
-    template?: string;
-    force: boolean;
-    install: boolean;
-}
-
-export const createCommand: Command<any, CreateOptions> = {
-    command: 'create [project-name]',
-    description: 'Scaffold a new Gjsify project in a new directory.',
-    builder: (yargs) => {
-        const templates = discoverTemplates();
-        const templateChoices = templates.map((t) => t.name);
-        return yargs
-            .positional('project-name', {
-                describe: 'Name of the project directory to create',
-                type: 'string',
-                default: 'my-gjs-app',
-            })
-            .option('template', {
-                alias: 't',
-                describe: 'Template to scaffold from',
-                type: 'string',
-                choices: templateChoices.length > 0 ? templateChoices : undefined,
-            })
-            .option('force', {
-                alias: 'f',
-                describe: 'Scaffold into a non-empty directory',
-                type: 'boolean',
-                default: false,
-            })
-            .option('install', {
-                describe: 'Run npm install after scaffolding',
-                type: 'boolean',
-                default: false,
-            });
-    },
-    handler: async (args) => {
-        let template = args.template;
-        if (!template) {
-            const templates = discoverTemplates();
-            if (!process.stdin.isTTY) {
-                const list = templates.map((t) => t.name).join(', ');
-                console.error(
-                    `Error: --template is required in non-interactive mode. Available templates: ${list || '(none)'}`,
-                );
-                process.exit(1);
-            }
-            const picked = await promptTemplate(templates);
-            template = picked.name;
-        }
-        await createProject({
-            projectName: args['project-name'],
-            template,
-            force: args.force,
-            install: args.install,
-        });
-    },
-};

package/src/commands/dlx.ts

@@ -1,195 +0,0 @@
-// `gjsify dlx <package> [bin] [-- args...]` — runs the GJS bundle of an
-// npm-published package without persisting it in the user's project.
-//
-// Cardinal rule: dlx is a **GJS-bundle runner**, not a generic bin runner.
-// It always invokes `gjs -m <bundle>` via the existing `runGjsBundle()` util.
-// Packages without a GJS entry (no `gjsify.main`/`gjsify.bin`, no fallback
-// `main`) fail loudly.
-//
-// Cache: $XDG_CACHE_HOME/gjsify/dlx/<sha256>/ with TTL (default 7d, override
-// via --cache-max-age=<minutes>). Cache hit on second run skips `npm install`
-// entirely. Layout + atomic-swap pattern adapted from pnpm's dlx implementation
-// (refs/pnpm/exec/commands/src/dlx.ts).
-
-import type { Command } from '../types/index.js';
-import { runGjsBundle } from '../utils/run-gjs.js';
-import { parseSpec, type ParsedSpec } from '../utils/parse-spec.js';
-import { resolveGjsEntry } from '../utils/resolve-gjs-entry.js';
-import {
-    cacheDirFor,
-    createCacheKey,
-    getValidCachedPkg,
-    makePrepareDir,
-    resolveInstalledPkgDir,
-    symlinkSwap,
-} from '../utils/dlx-cache.js';
-import { installPackages } from '../utils/install-backend.js';
-
-interface DlxOptions {
-    spec: string;
-    binOrArg?: string;
-    extraArgs?: string[];
-    'cache-max-age': number;
-    reinstall: boolean;
-    frozen: boolean;
-    verbose: boolean;
-    registry?: string;
-}
-
-export const dlxCommand: Command<any, DlxOptions> = {
-    command: 'dlx <spec> [binOrArg] [extraArgs..]',
-    description:
-        'Run the GJS bundle of an npm-published package without installing it locally.',
-    builder: (yargs) =>
-        yargs
-            .positional('spec', {
-                description:
-                    'Package spec (`name`, `name@version`, `@scope/name@spec`, or local path).',
-                type: 'string',
-                demandOption: true,
-            })
-            .positional('binOrArg', {
-                description:
-                    'Optional bin name when the package defines `gjsify.bin` with multiple entries; otherwise treated as the first argument forwarded to the bundle.',
-                type: 'string',
-            })
-            .positional('extraArgs', {
-                description: 'Extra args forwarded to `gjs -m <bundle>`.',
-                type: 'string',
-                array: true,
-            })
-            .option('cache-max-age', {
-                description:
-                    'Cache TTL in minutes. Defaults to 7 days. Use 0 to bypass cache.',
-                type: 'number',
-                default: 60 * 24 * 7,
-            })
-            .option('reinstall', {
-                description:
-                    'Bypass the cache for this run (alias for --cache-max-age=0).',
-                type: 'boolean',
-                default: false,
-            })
-            .option('frozen', {
-                description:
-                    'Use the project-local gjsify-lock.json verbatim — fail if missing or stale (no resolver pass).',
-                type: 'boolean',
-                default: false,
-            })
-            .option('verbose', {
-                description: 'Verbose logging (passes --loglevel verbose to npm).',
-                type: 'boolean',
-                default: false,
-            })
-            .option('registry', {
-                description: 'Registry URL override.',
-                type: 'string',
-            }),
-    handler: async (args) => {
-        const parsed = parseSpec(args.spec);
-
-        const cacheMaxAge = args.reinstall ? 0 : args['cache-max-age'];
-        const { pkgDir, cachedPkgName } = await ensurePkgDir(parsed, {
-            verbose: args.verbose,
-            registry: args.registry,
-            cacheMaxAge,
-            frozen: args.frozen,
-        });
-
-        // Bin / args disambiguation:
-        //   gjsify dlx <pkg>                         → no bin, no args
-        //   gjsify dlx <pkg> mybin                   → bin if package has gjsify.bin[mybin], else arg
-        //   gjsify dlx <pkg> mybin -- arg1 arg2      → bin + extra args
-        //   gjsify dlx <pkg> -- arg1 arg2            → no bin, extra args
-        const { binName, extraArgs } = splitBinAndArgs(
-            pkgDir,
-            args.binOrArg,
-            args.extraArgs ?? [],
-        );
-
-        const entry = resolveGjsEntry(pkgDir, binName);
-        if (entry.fromFallback) {
-            console.warn(
-                `[gjsify dlx] package "${cachedPkgName ?? parsed.kind}" has no \`gjsify\` field — falling back to package.json#main. Add \`gjsify.main\` to silence.`,
-            );
-        }
-
-        await runGjsBundle(entry.bundlePath, extraArgs);
-    },
-};
-
-interface EnsureOpts {
-    verbose: boolean;
-    registry?: string;
-    cacheMaxAge: number;
-    frozen: boolean;
-}
-
-async function ensurePkgDir(
-    parsed: ParsedSpec,
-    opts: EnsureOpts,
-): Promise<{ pkgDir: string; cachedPkgName: string | null }> {
-    if (parsed.kind === 'local') {
-        return { pkgDir: parsed.path, cachedPkgName: null };
-    }
-
-    const cacheKey = createCacheKey({ packages: [parsed.spec] });
-    const cacheDir = cacheDirFor(cacheKey);
-
-    const cached = opts.cacheMaxAge > 0 ? getValidCachedPkg(cacheDir, opts.cacheMaxAge) : undefined;
-    if (cached) {
-        return {
-            pkgDir: resolveInstalledPkgDir(cached, parsed.name),
-            cachedPkgName: parsed.name,
-        };
-    }
-
-    const prepareDir = makePrepareDir(cacheDir);
-    await installPackages({
-        prefix: prepareDir,
-        specs: [parsed.spec],
-        verbose: opts.verbose,
-        registry: opts.registry,
-        // Cache-prepare dirs are scoped per cache key, so writing a lockfile
-        // there gives us reproducibility for repeated `gjsify dlx <pkg>` calls
-        // and lets `--frozen` short-circuit the resolver entirely.
-        lockfile: true,
-        frozen: opts.frozen,
-    });
-
-    const liveTarget = symlinkSwap(cacheDir, prepareDir);
-    return {
-        pkgDir: resolveInstalledPkgDir(liveTarget, parsed.name),
-        cachedPkgName: parsed.name,
-    };
-}
-
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-function splitBinAndArgs(
-    pkgDir: string,
-    binOrArg: string | undefined,
-    extraArgs: string[],
-): { binName: string | null; extraArgs: string[] } {
-    if (!binOrArg) {
-        return { binName: null, extraArgs };
-    }
-
-    const pkgJsonPath = join(pkgDir, 'package.json');
-    if (existsSync(pkgJsonPath)) {
-        try {
-            const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8')) as {
-                gjsify?: { bin?: Record<string, string> };
-            };
-            const bins = pkg.gjsify?.bin;
-            if (bins && Object.prototype.hasOwnProperty.call(bins, binOrArg)) {
-                return { binName: binOrArg, extraArgs };
-            }
-        } catch {
-            // Fall through to treating as an arg.
-        }
-    }
-    // Not a known bin — treat the positional as the first argv to the bundle.
-    return { binName: null, extraArgs: [binOrArg, ...extraArgs] };
-}

package/src/commands/flatpak/build.ts

@@ -1,225 +0,0 @@
-// `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';
-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 const flatpakBuildCommand: Command<unknown, FlatpakBuildOptions> = {
-    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 as string | undefined) ?? 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: string[] = [];
-        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: string): string {
-    return scanForManifest(cwd) ?? 'flatpak.json';
-}
-
-function scanForManifest(cwd: string): string | undefined {
-    let entries: string[] = [];
-    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')) as Record<string, unknown>;
-            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: string): string {
-    const raw = readFileSync(manifest, 'utf-8');
-    const json = JSON.parse(raw) as { id?: unknown };
-    if (typeof json.id !== 'string') {
-        throw new Error(`gjsify flatpak build: ${manifest} has no string "id" field`);
-    }
-    return json.id;
-}
-
-async function runFlatpakBuilder(args: string[], opts: { verbose?: boolean }) {
-    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: string[], opts: { verbose?: boolean }) {
-    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: string[], opts: { verbose?: boolean }) {
-    return runProc('tar', args, opts, { notFoundHint: 'tar not found.' });
-}
-
-function runProc(
-    cmd: string,
-    args: string[],
-    opts: { verbose?: boolean },
-    extra: { notFoundHint: string },
-): Promise<void> {
-    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: NodeJS.ErrnoException) => {
-            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/src/commands/flatpak/ci.ts

@@ -1,173 +0,0 @@
-// `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 type { Command, ConfigData, ConfigDataFlatpak } from '../../types/index.js';
-import { Config } from '../../config.js';
-import { defaultCiContainer, looksLikeAppId, readPackageJson, resolveRuntime } from './utils.js';
-
-interface FlatpakCiOptions {
-    manifest?: string;
-    bundle?: string;
-    runtimeImage?: string;
-    branches?: string[];
-    out?: string;
-    force?: boolean;
-    cacheKey?: string;
-    verbose?: boolean;
-}
-
-export const flatpakCiCommand: Command<unknown, FlatpakCiOptions> = {
-    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({} as never).catch(() => ({} as ConfigData));
-        const flatpak: ConfigDataFlatpak = configData.flatpak ?? {};
-        const pkg = readPackageJson(cwd);
-
-        const appId =
-            flatpak.appId ??
-            (looksLikeAppId(pkg.name) ? (pkg.name as string) : 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 as string | undefined) ?? `${appId}.json`;
-        const bundle = (args.bundle as string | undefined) ?? `${appId}.flatpak`;
-
-        const { runtime, runtimeVersion } = resolveRuntime(flatpak, {});
-        const runtimeImage =
-            (args.runtimeImage as string | undefined) ??
-            flatpak.ciContainer ??
-            defaultCiContainer(runtime, runtimeVersion);
-
-        const branches = (args.branches as string[] | undefined) ?? 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}`);
-    },
-};
-
-interface RenderInput {
-    manifest: string;
-    bundle: string;
-    runtimeImage: string;
-    branches: string[];
-    cacheKey: string;
-}
-
-/**
- * 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: RenderInput): string {
-    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}
-`;
-}