@gjsify/cli 0.3.21 → 0.4.0

package/src/commands/check.ts

@@ -1,87 +0,0 @@
-import type { Command } from '../types/index.js';
-import { runAllChecks, detectPackageManager, buildInstallCommand } from '../utils/check-system-deps.js';
-
-interface CheckOptions {
-    json: boolean;
-}
-
-export const checkCommand: Command<any, CheckOptions> = {
-    command: 'check',
-    description: 'Check that required system dependencies (GJS, GTK4, libsoup3, …) are installed. Optional dependencies are detected only when their @gjsify/* package is in your project.',
-    builder: (yargs) => {
-        return yargs
-            .option('json', {
-                description: 'Output results as JSON',
-                type: 'boolean',
-                default: false,
-            });
-    },
-    handler: async (args) => {
-        const results = runAllChecks(process.cwd());
-        const pm = detectPackageManager();
-        const missingRequired = results.filter(r => !r.found && r.severity === 'required');
-        const missingOptional = results.filter(r => !r.found && r.severity === 'optional');
-        const allMissing = [...missingRequired, ...missingOptional];
-
-        if (args.json) {
-            console.log(JSON.stringify({ packageManager: pm, deps: results }, null, 2));
-            // Only required deps influence the exit code.
-            process.exit(missingRequired.length > 0 ? 1 : 0);
-            return;
-        }
-
-        console.log('System dependency check\n');
-
-        const required = results.filter(r => r.severity === 'required');
-        const optional = results.filter(r => r.severity === 'optional');
-
-        if (required.length > 0) {
-            console.log('Required:');
-            for (const dep of required) {
-                const icon = dep.found ? '✓' : '✗';
-                const ver = dep.version ? `  (${dep.version})` : '';
-                console.log(`  ${icon}  ${dep.name}${ver}`);
-            }
-        }
-
-        if (optional.length > 0) {
-            console.log('\nOptional:');
-            for (const dep of optional) {
-                // ⚠ for missing-but-needed-by-installed-packages, ○ for missing-but-not-needed (shouldn't appear in conditional mode)
-                const icon = dep.found ? '✓' : '⚠';
-                const ver = dep.version ? `  (${dep.version})` : '';
-                const requiredBy = dep.requiredBy && dep.requiredBy.length > 0
-                    ? `  — needed by ${dep.requiredBy.join(', ')}`
-                    : '';
-                console.log(`  ${icon}  ${dep.name}${ver}${requiredBy}`);
-            }
-        }
-
-        console.log(`\nPackage manager: ${pm}`);
-
-        if (allMissing.length === 0) {
-            console.log('\nAll dependencies found.');
-            return;
-        }
-
-        if (missingRequired.length > 0) {
-            console.log(`\nMissing required: ${missingRequired.map(d => d.name).join(', ')}`);
-        }
-        if (missingOptional.length > 0) {
-            console.log(`Missing optional: ${missingOptional.map(d => d.name).join(', ')}`);
-        }
-
-        const cmd = buildInstallCommand(pm, allMissing);
-        if (cmd) {
-            console.log(`\nTo install:\n  ${cmd}`);
-        } else {
-            console.log('\nNo install command available for your package manager. Install manually.');
-        }
-
-        // Exit non-zero ONLY if a required dependency is missing.
-        // Optional deps that are missing but needed by an installed @gjsify/*
-        // package generate a warning but keep exit code 0 — the user can still
-        // build/run code paths that don't touch the optional library.
-        process.exit(missingRequired.length > 0 ? 1 : 0);
-    },
-};

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}`));
-        });
-    });
-}