@gjsify/cli 0.4.9 → 0.4.11

package/lib/commands/generate-installer.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from '../types/index.js';
+interface GenerateInstallerOptions {
+    target?: string;
+    'bin-name'?: string;
+    'bootstrap-url'?: string;
+    output: string;
+    force: boolean;
+}
+export declare const generateInstallerCommand: Command<any, GenerateInstallerOptions>;
+export {};

package/lib/commands/generate-installer.js

@@ -0,0 +1,113 @@
+// `gjsify generate-installer [target]` — scaffold an `install.mjs` for any
+// GJS-runnable npm package, modeled on gjsify's own installer.
+//
+// The generated `install.mjs` is a verbatim copy of gjsify's root `install.mjs`
+// with three constants substituted:
+//
+//   DEFAULT_TARGET      → the consumer's npm package name
+//   DEFAULT_BIN_NAME    → the consumer's bin name (key of `gjsify.bin` or `bin`)
+//   DEFAULT_BOOTSTRAP_URL → URL of a gjsify `cli.gjs.mjs` bootstrap bundle
+//
+// End-user workflow:
+//   cd my-gjs-app
+//   gjsify generate-installer
+//   git add install.mjs && git commit
+//   # README:
+//   #   curl -fsSL https://github.com/me/my-gjs-app/raw/main/install.mjs \
+//   #     -o /tmp/i.mjs && gjs -m /tmp/i.mjs && rm /tmp/i.mjs
+//
+// The template is read at build time (static-read-inliner inlines the file
+// contents into the bundled CLI), so the runtime cost is just a string
+// replace + write.
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+// Lazy load. Reading at the top level breaks `gjsify run copy-templates`
+// (the bootstrap step that ships the template into `lib/templates/` after
+// `tsc`): the run script must first import this module to dispatch into
+// itself, which would then ENOENT on the not-yet-copied template file.
+// The static-read-inliner can still detect this shape inside the handler.
+function loadInstallerTemplate() {
+    return readFileSync(new URL('../templates/install.mjs.tmpl', import.meta.url), 'utf-8');
+}
+const DEFAULT_BOOTSTRAP_URL = 'https://github.com/gjsify/gjsify/releases/latest/download/cli.gjs.mjs';
+export const generateInstallerCommand = {
+    command: 'generate-installer [target]',
+    description: 'Scaffold an install.mjs in the current directory for a GJS-runnable npm package.',
+    builder: (yargs) => yargs
+        .positional('target', {
+        description: 'Npm package name to install (default: current package.json name).',
+        type: 'string',
+    })
+        .option('bin-name', {
+        description: 'Bin name produced by the installer (default: first key of `gjsify.bin` or `bin`).',
+        type: 'string',
+    })
+        .option('bootstrap-url', {
+        description: 'Override the cli.gjs.mjs bootstrap bundle URL (default: gjsify GitHub releases/latest).',
+        type: 'string',
+    })
+        .option('output', {
+        description: 'Where to write the generated installer.',
+        type: 'string',
+        default: 'install.mjs',
+    })
+        .option('force', {
+        description: 'Overwrite an existing output file.',
+        type: 'boolean',
+        default: false,
+    }),
+    handler: (args) => {
+        const outputPath = resolve(process.cwd(), args.output);
+        if (existsSync(outputPath) && !args.force) {
+            console.error(`${args.output} already exists. Re-run with --force to overwrite.`);
+            process.exit(1);
+            return;
+        }
+        const pkgJsonPath = resolve(process.cwd(), 'package.json');
+        let pkgJson = null;
+        if (existsSync(pkgJsonPath)) {
+            try {
+                pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+            }
+            catch {
+                /* no pkg.json or unparsable — fall back to flags */
+            }
+        }
+        const target = args.target ?? pkgJson?.name;
+        if (!target) {
+            console.error('No target package: pass `gjsify generate-installer <pkg>` or run inside a directory with a package.json.');
+            process.exit(1);
+            return;
+        }
+        const binName = args['bin-name'] ?? pickDefaultBinName(pkgJson, target);
+        const bootstrapUrl = args['bootstrap-url'] ?? DEFAULT_BOOTSTRAP_URL;
+        const rendered = loadInstallerTemplate()
+            .replace(/const DEFAULT_TARGET = '[^']+';/, `const DEFAULT_TARGET = ${JSON.stringify(target)};`)
+            .replace(/const DEFAULT_BIN_NAME = '[^']+';/, `const DEFAULT_BIN_NAME = ${JSON.stringify(binName)};`)
+            .replace(/const DEFAULT_BOOTSTRAP_URL =\s*'[^']+';/, `const DEFAULT_BOOTSTRAP_URL = ${JSON.stringify(bootstrapUrl)};`);
+        writeFileSync(outputPath, rendered, { mode: 0o755 });
+        console.log(`Wrote ${args.output} (target=${target}, bin=${binName}).`);
+        console.log('');
+        console.log('Install one-liner for your README:');
+        console.log(`  curl -fsSL https://github.com/<you>/<repo>/raw/main/${args.output} -o /tmp/i.mjs \\`);
+        console.log('    && gjs -m /tmp/i.mjs && rm /tmp/i.mjs');
+    },
+};
+function pickDefaultBinName(pkgJson, target) {
+    const gjsifyBin = pkgJson?.gjsify?.bin;
+    if (gjsifyBin && typeof gjsifyBin === 'object') {
+        const first = Object.keys(gjsifyBin)[0];
+        if (first)
+            return first;
+    }
+    const npmBin = pkgJson?.bin;
+    if (npmBin && typeof npmBin === 'object') {
+        const first = Object.keys(npmBin)[0];
+        if (first)
+            return first;
+    }
+    if (typeof npmBin === 'string') {
+        return target.startsWith('@') ? target.slice(target.indexOf('/') + 1) : target;
+    }
+    return target.startsWith('@') ? target.slice(target.indexOf('/') + 1) : target;
+}

package/lib/commands/index.d.ts

@@ -14,3 +14,6 @@ export * from './foreach.js';
 export * from './workspace.js';
 export * from './pack.js';
 export * from './publish.js';
+export * from './self-update.js';
+export * from './generate-installer.js';
+export * from './uninstall.js';

package/lib/commands/index.js

@@ -14,3 +14,6 @@ export * from './foreach.js';
 export * from './workspace.js';
 export * from './pack.js';
 export * from './publish.js';
+export * from './self-update.js';
+export * from './generate-installer.js';
+export * from './uninstall.js';

package/lib/commands/self-update.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from '../types/index.js';
+interface SelfUpdateOptions {
+    check?: boolean;
+    force?: boolean;
+    tag: string;
+}
+export declare const selfUpdateCommand: Command<any, SelfUpdateOptions>;
+export {};

package/lib/commands/self-update.js

@@ -0,0 +1,138 @@
+// `gjsify self-update` — refresh the installed @gjsify/cli to a newer release.
+//
+// Walks `import.meta.url` to find this CLI's own package.json (works whether
+// running from `lib/index.js` under Node or the published `dist/cli.gjs.mjs`
+// bundle under GJS). Compares against the latest version on the npm registry
+// (or the requested `--tag`); when an upgrade is needed, re-uses the existing
+// `installPackages` + `linkGlobalBins` pipeline to lay down the new tree at
+// the user-global XDG location.
+//
+// Limitation: only works when the current CLI is installed under
+// `defaultGlobalLayout().prefix` (i.e. via `gjsify install -g` or via the
+// `install.mjs` bootstrap). Installs from `npm install -g @gjsify/cli` land
+// elsewhere and we don't try to chase them — we print a warning and exit.
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { fetchPackument } from '@gjsify/npm-registry';
+import { installPackages } from '../utils/install-backend.js';
+import { defaultGlobalLayout, linkGlobalBins } from '../utils/install-global.js';
+const PACKAGE_NAME = '@gjsify/cli';
+export const selfUpdateCommand = {
+    command: 'self-update',
+    description: `Update the installed ${PACKAGE_NAME} to the latest release (or pinned --tag).`,
+    builder: (yargs) => yargs
+        .option('check', {
+        description: 'Only check whether a newer version is available; do not install.',
+        type: 'boolean',
+        default: false,
+    })
+        .option('force', {
+        description: 'Reinstall even when the current version already matches the target tag.',
+        type: 'boolean',
+        default: false,
+    })
+        .option('tag', {
+        description: 'npm dist-tag or pinned version to install (e.g. `latest`, `next`, `0.5.0`).',
+        type: 'string',
+        default: 'latest',
+    }),
+    handler: async (args) => {
+        const layout = defaultGlobalLayout();
+        const installedPkgDir = join(layout.prefix, 'node_modules', PACKAGE_NAME);
+        const installedPkgJson = join(installedPkgDir, 'package.json');
+        const currentVersion = readCurrentVersion();
+        const installedAtPrefix = existsSync(installedPkgJson);
+        console.log(`Current ${PACKAGE_NAME}: v${currentVersion ?? '(unknown)'}`);
+        if (!installedAtPrefix) {
+            console.warn(`\nWarning: no @gjsify/cli install found under ${layout.prefix}.\n` +
+                `self-update only manages installs created by install.mjs or \`gjsify install -g\`.\n` +
+                `If you installed via \`npm install -g\`, remove that and use:\n` +
+                `  curl -fsSL https://github.com/gjsify/gjsify/releases/latest/download/install.mjs -o /tmp/g.mjs && gjs -m /tmp/g.mjs && rm /tmp/g.mjs`);
+        }
+        console.log(`Fetching dist-tags for ${PACKAGE_NAME}@${args.tag} ...`);
+        let packument;
+        try {
+            packument = await fetchPackument(PACKAGE_NAME);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to fetch packument: ${msg}`);
+            process.exit(1);
+            return;
+        }
+        const target = resolveTag(packument, args.tag);
+        if (!target) {
+            console.error(`Unknown dist-tag '${args.tag}' on ${PACKAGE_NAME}. ` +
+                `Known tags: ${Object.keys(packument['dist-tags'] ?? {}).join(', ') || '(none)'}`);
+            process.exit(1);
+            return;
+        }
+        console.log(`Latest matching --tag ${args.tag}: v${target}`);
+        if (currentVersion === target && !args.force) {
+            console.log(`Already up to date (v${target}).`);
+            if (!args.check)
+                console.log(`Run with --force to reinstall anyway.`);
+            return;
+        }
+        if (args.check) {
+            console.log(currentVersion
+                ? `Update available: v${currentVersion} → v${target}`
+                : `Install required: → v${target}`);
+            process.exit(1);
+            return;
+        }
+        console.log(`Installing ${PACKAGE_NAME}@${target} ...`);
+        await installPackages({
+            prefix: layout.prefix,
+            specs: [`${PACKAGE_NAME}@${target}`],
+            verbose: false,
+        });
+        const linked = linkGlobalBins([PACKAGE_NAME], layout);
+        if (linked.length === 0) {
+            console.warn('self-update: install completed but no bins were linked — package.json may be missing a `bin` field.');
+        }
+        else {
+            for (const bin of linked) {
+                console.log(`  • ${bin.link}  →  ${bin.target}`);
+            }
+        }
+        console.log(`\nUpdated ${PACKAGE_NAME} to v${target}.`);
+    },
+};
+/**
+ * Resolve the CLI's own `package.json#version`. Walks up from
+ * `import.meta.url` (the bundle file under GJS, or `lib/index.js` under
+ * Node) until it finds a package.json with `name === '@gjsify/cli'`.
+ */
+function readCurrentVersion() {
+    try {
+        const here = fileURLToPath(import.meta.url);
+        let dir = dirname(resolve(here));
+        for (let i = 0; i < 8 && dir !== dirname(dir); i++) {
+            const candidate = join(dir, 'package.json');
+            if (existsSync(candidate)) {
+                const pkg = JSON.parse(readFileSync(candidate, 'utf-8'));
+                if (pkg.name === PACKAGE_NAME && typeof pkg.version === 'string') {
+                    return pkg.version;
+                }
+            }
+            dir = dirname(dir);
+        }
+    }
+    catch {
+        /* not in a recognizable layout */
+    }
+    return null;
+}
+function resolveTag(packument, tag) {
+    const distTags = (packument['dist-tags'] ?? {});
+    if (distTags[tag])
+        return distTags[tag];
+    // Allow pinned versions via `--tag 0.5.0`
+    if (packument.versions && typeof packument.versions === 'object') {
+        if (packument.versions[tag])
+            return tag;
+    }
+    return null;
+}

package/lib/commands/uninstall.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from '../types/index.js';
+interface UninstallOptions {
+    packages: string[];
+    global?: boolean;
+    'dry-run'?: boolean;
+    verbose?: boolean;
+}
+export declare const uninstallCommand: Command<any, UninstallOptions>;
+export {};

package/lib/commands/uninstall.js

@@ -0,0 +1,145 @@
+// `gjsify uninstall -g <pkg>` — symmetric inverse of `install -g`.
+//
+// Removes the installed package tree from the user-global XDG location
+// and any bin shims under `~/.local/bin/` that point into it. Mirrors
+// the layout decisions in install-global.ts:
+//
+//   ~/.local/share/gjsify/global/node_modules/<pkg>/   ← deleted
+//   ~/.local/bin/<bin>                                  ← deleted iff it
+//                                                        execs a path
+//                                                        inside the
+//                                                        removed tree
+//
+// Scope: --global only. Project-local uninstall (mirror of `npm uninstall
+// <pkg>` without -g) is a separate workstream — it needs to rewrite
+// package.json + refresh the lockfile, which install -g doesn't touch.
+import { existsSync, readFileSync, readdirSync, rmSync, statSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { defaultGlobalLayout, specToPackageName } from '../utils/install-global.js';
+export const uninstallCommand = {
+    command: 'uninstall <packages..>',
+    description: 'Uninstall a previously installed package. Currently only `--global` mode is supported.',
+    builder: (yargs) => yargs
+        .positional('packages', {
+        description: 'Package(s) to uninstall (npm names, optionally with version).',
+        type: 'string',
+        array: true,
+        demandOption: true,
+    })
+        .option('global', {
+        description: 'Uninstall from the user-global XDG location (the install -g target).',
+        type: 'boolean',
+        alias: 'g',
+        default: false,
+    })
+        .option('dry-run', {
+        description: 'Show what would be removed without touching the filesystem.',
+        type: 'boolean',
+        default: false,
+    })
+        .option('verbose', {
+        description: 'Verbose logging.',
+        type: 'boolean',
+        default: false,
+    }),
+    handler: (args) => {
+        if (!args.global) {
+            console.error('gjsify uninstall currently only supports --global. ' +
+                'For project-local removal, edit package.json + re-run `gjsify install`.');
+            process.exit(1);
+            return;
+        }
+        const layout = defaultGlobalLayout();
+        const dryRun = args['dry-run'] ?? false;
+        const verbose = args.verbose ?? false;
+        const prefix = `gjsify uninstall${dryRun ? ' (dry-run)' : ''} --global`;
+        console.log(`${prefix}  ← ${layout.prefix}`);
+        console.log(`${' '.repeat(prefix.length)}      bins ← ${layout.binDir}`);
+        let removedAny = false;
+        for (const spec of args.packages) {
+            const pkgName = specToPackageName(spec);
+            const pkgDir = join(layout.prefix, 'node_modules', pkgName);
+            if (!existsSync(pkgDir)) {
+                console.warn(`  ✗  ${pkgName} — not installed at ${pkgDir}`);
+                continue;
+            }
+            // Find bin shims that exec into this package's tree. The shims
+            // are POSIX sh launchers written by linkGlobalBins; we identify
+            // candidates by reading the launcher script and matching the
+            // absolute path.
+            const binsToRemove = findBinShimsForPackage(layout.binDir, pkgDir, verbose);
+            if (dryRun) {
+                console.log(`  •  would remove ${pkgDir}`);
+                for (const bin of binsToRemove) {
+                    console.log(`  •  would remove ${bin}`);
+                }
+            }
+            else {
+                rmSync(pkgDir, { recursive: true, force: true });
+                console.log(`  •  removed ${pkgDir}`);
+                for (const bin of binsToRemove) {
+                    unlinkSync(bin);
+                    console.log(`  •  removed ${bin}`);
+                }
+            }
+            removedAny = true;
+        }
+        if (!removedAny) {
+            console.error('\nNo packages removed.');
+            process.exit(1);
+        }
+    },
+};
+/**
+ * Scan `binDir` for POSIX `sh` launchers whose `exec` target points into
+ * `pkgDir`. The launcher shape is fixed by `linkGlobalBins` — either:
+ *
+ *   #!/bin/sh
+ *   exec '<absolute-path>' "$@"
+ *
+ * or (for `.gjs.mjs` / `.mjs` targets):
+ *
+ *   #!/bin/sh
+ *   exec gjs -m '<absolute-path>' "$@"
+ *
+ * We parse the absolute path out of the single-quoted segment and check
+ * whether it's under `pkgDir`. Non-shim files (e.g. unrelated binaries
+ * the user installed via `npm install -g`) are skipped silently.
+ */
+function findBinShimsForPackage(binDir, pkgDir, verbose) {
+    if (!existsSync(binDir))
+        return [];
+    const matches = [];
+    let entries;
+    try {
+        entries = readdirSync(binDir);
+    }
+    catch {
+        return [];
+    }
+    for (const name of entries) {
+        const fullPath = join(binDir, name);
+        try {
+            const st = statSync(fullPath);
+            if (!st.isFile())
+                continue;
+            const content = readFileSync(fullPath, 'utf-8');
+            if (!content.startsWith('#!/bin/sh'))
+                continue;
+            // Match the first single-quoted absolute path.
+            const m = content.match(/'([^']+)'/);
+            if (!m)
+                continue;
+            const target = m[1];
+            if (target.startsWith(pkgDir + '/') || target === pkgDir) {
+                matches.push(fullPath);
+            }
+        }
+        catch (err) {
+            if (verbose) {
+                console.warn(`  ?  could not inspect ${fullPath}: ${err.message}`);
+            }
+        }
+    }
+    return matches;
+}

package/lib/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import { buildCommand as build, runCommand as run, infoCommand as info, checkCommand as check, showcaseCommand as showcase, createCommand as create, gresourceCommand as gresource, gettextCommand as gettext, gsettingsCommand as gsettings, flatpakCommand as flatpak, dlxCommand as dlx, installCommand as install, foreachCommand as foreach, workspaceCommand as workspace, packCommand as pack, publishCommand as publish, } from './commands/index.js';
+import { buildCommand as build, runCommand as run, infoCommand as info, checkCommand as check, showcaseCommand as showcase, createCommand as create, gresourceCommand as gresource, gettextCommand as gettext, gsettingsCommand as gsettings, flatpakCommand as flatpak, dlxCommand as dlx, installCommand as install, foreachCommand as foreach, workspaceCommand as workspace, packCommand as pack, publishCommand as publish, selfUpdateCommand as selfUpdate, generateInstallerCommand as generateInstaller, uninstallCommand as uninstall, } from './commands/index.js';
 import { APP_NAME } from './constants.js';
 // `parseAsync()` instead of `.argv` so the top-level await keeps the
 // process alive until command handlers complete. Under Node this is
@@ -27,6 +27,9 @@ await yargs(hideBin(process.argv))
     .command(workspace.command, workspace.description, workspace.builder, workspace.handler)
     .command(pack.command, pack.description, pack.builder, pack.handler)
     .command(publish.command, publish.description, publish.builder, publish.handler)
+    .command(selfUpdate.command, selfUpdate.description, selfUpdate.builder, selfUpdate.handler)
+    .command(generateInstaller.command, generateInstaller.description, generateInstaller.builder, generateInstaller.handler)
+    .command(uninstall.command, uninstall.description, uninstall.builder, uninstall.handler)
     .demandCommand(1)
     .help()
     .parseAsync();