@gjsify/cli 0.4.5 → 0.4.10

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

@@ -12,3 +12,7 @@ export * from './dlx.js';
 export * from './install.js';
 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';

package/lib/commands/index.js

@@ -12,3 +12,7 @@ export * from './dlx.js';
 export * from './install.js';
 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';

package/lib/commands/pack.d.ts

@@ -0,0 +1,40 @@
+import type { Command } from '../types/index.js';
+interface PackOptions {
+    path?: string;
+    'pack-destination'?: string;
+    json?: boolean;
+    'dry-run'?: boolean;
+}
+interface PackResult {
+    filename: string;
+    name: string;
+    version: string;
+    size: number;
+    unpackedSize: number;
+    shasum: string;
+    integrity: string;
+    entryCount: number;
+    files: {
+        path: string;
+        size: number;
+        mode: number;
+    }[];
+    /** Absolute path of the written .tgz, or null on --dry-run. */
+    absolutePath: string | null;
+}
+export declare const packCommand: Command<any, PackOptions>;
+export interface PackWorkspaceOptions {
+    /** Directory to write the .tgz into. Defaults to the workspace itself. */
+    destination?: string;
+    /** Skip writing the .tgz; metadata is still computed (for npm-compat callers). */
+    dryRun?: boolean;
+    /** Skip the workspace:^ rewrite step (rare — useful for testing the raw layout). */
+    skipWorkspaceRewrite?: boolean;
+}
+/**
+ * Programmatic equivalent of the `pack` command — used by `gjsify publish`
+ * to avoid spawning a subprocess. Caller is responsible for resolving
+ * `wsDir` to an absolute path.
+ */
+export declare function packWorkspace(wsDir: string, opts?: PackWorkspaceOptions): Promise<PackResult>;
+export {};

package/lib/commands/pack.js

@@ -0,0 +1,335 @@
+// `gjsify pack [path] [--pack-destination <dir>] [--json]` — npm-compatible
+// tarball creation for the workspace at `path` (default: cwd).
+//
+// Output shape matches `npm pack --json`:
+//   [
+//     {
+//       "filename": "scope-name-1.2.3.tgz",
+//       "name": "@scope/name",
+//       "version": "1.2.3",
+//       "size": <unpacked bytes>,
+//       "unpackedSize": <unpacked bytes>,
+//       "shasum": "<sha1 hex>",
+//       "integrity": "sha512-<base64>",
+//       "files": [ { path, size, mode }, ... ],
+//       "entryCount": <int>
+//     }
+//   ]
+//
+// File selection mirrors npm pack: explicit `files` field if present, else
+// the default allowlist (README/LICENSE/package.json + main entry + bin). The
+// implementation here is conservative — when no `files` field is set we walk
+// the workspace recursively and apply the implicit-exclusion set
+// (.git, node_modules, …) plus .npmignore / .gitignore. workspace:^ deps in
+// package.json are rewritten to resolved npm version ranges based on the
+// sibling workspaces' own versions, so the published tarball is consumable.
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { join, resolve } from 'node:path';
+import { createTarball, gzip } from '@gjsify/tar';
+import { discoverWorkspaces } from '@gjsify/workspace';
+import { findWorkspaceRoot } from '../utils/workspace-root.js';
+export const packCommand = {
+    command: 'pack [path]',
+    description: 'Produce an npm-compatible .tgz tarball for the workspace at <path> (default: cwd). Rewrites workspace:^/~/* deps to resolved versions.',
+    builder: (yargs) => yargs
+        .positional('path', {
+        description: 'Workspace path (default: cwd).',
+        type: 'string',
+    })
+        .option('pack-destination', {
+        description: 'Directory to write the tarball into. Default: workspace cwd.',
+        type: 'string',
+    })
+        .option('json', {
+        description: 'Emit pack metadata as JSON on stdout (mirrors `npm pack --json`).',
+        type: 'boolean',
+        default: false,
+    })
+        .option('dry-run', {
+        description: 'Compute everything but do not write the .tgz.',
+        type: 'boolean',
+        default: false,
+    }),
+    handler: async (args) => {
+        const wsDir = resolve(args.path ?? process.cwd());
+        const result = await packWorkspace(wsDir, {
+            destination: args['pack-destination'],
+            dryRun: args['dry-run'] === true,
+        });
+        if (args.json) {
+            process.stdout.write(`${JSON.stringify([result], null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(`${result.filename}\n`);
+        }
+    },
+};
+/**
+ * Programmatic equivalent of the `pack` command — used by `gjsify publish`
+ * to avoid spawning a subprocess. Caller is responsible for resolving
+ * `wsDir` to an absolute path.
+ */
+export async function packWorkspace(wsDir, opts = {}) {
+    const pkgPath = join(wsDir, 'package.json');
+    if (!existsSync(pkgPath)) {
+        throw new Error(`gjsify pack: no package.json at ${wsDir}`);
+    }
+    const originalSource = readFileSync(pkgPath, 'utf-8');
+    const pkg = JSON.parse(originalSource);
+    const name = typeof pkg.name === 'string' ? pkg.name : '';
+    const version = typeof pkg.version === 'string' ? pkg.version : '0.0.0';
+    if (!name) {
+        throw new Error(`gjsify pack: package.json at ${wsDir} has no "name"`);
+    }
+    // Rewrite workspace:^/~/* deps to resolved npm version ranges, mirroring
+    // yarn's auto-rewrite at publish time. Done in-memory only — the source
+    // package.json on disk is never mutated by `gjsify pack`.
+    const rewrittenPkg = opts.skipWorkspaceRewrite
+        ? pkg
+        : rewriteWorkspaceDeps(pkg, wsDir);
+    const rewrittenSource = JSON.stringify(rewrittenPkg, null, indentOf(originalSource)) + '\n';
+    // Collect files according to the package.json `files` field (or npm's
+    // default set). The package.json itself is always included with the
+    // rewritten contents.
+    const filesToPack = collectFiles(wsDir, pkg);
+    const entries = [{ name: 'package/', directory: true, mode: 0o755 }];
+    const fileMetas = [];
+    let unpackedSize = 0;
+    for (const rel of filesToPack) {
+        let body;
+        if (rel === 'package.json') {
+            body = new TextEncoder().encode(rewrittenSource);
+        }
+        else {
+            body = new Uint8Array(readFileSync(join(wsDir, rel)));
+        }
+        const st = statSync(join(wsDir, rel));
+        const mode = st.mode & 0o777;
+        entries.push({ name: `package/${rel}`, body, mode, mtime: 0 });
+        fileMetas.push({ path: rel, size: body.byteLength, mode });
+        unpackedSize += body.byteLength;
+    }
+    const tarBytes = createTarball(entries);
+    const gzipBytes = await gzip(tarBytes);
+    // npm filename: scope replaced with leading dash. "@gjsify/foo" → "gjsify-foo".
+    const filenameBase = name.startsWith('@')
+        ? name.slice(1).replace('/', '-')
+        : name;
+    const filename = `${filenameBase}-${version}.tgz`;
+    const sha1 = createHash('sha1').update(gzipBytes).digest('hex');
+    const sha512 = createHash('sha512').update(gzipBytes).digest('base64');
+    const integrity = `sha512-${sha512}`;
+    const destDir = opts.destination ? resolve(opts.destination) : wsDir;
+    const tarPath = join(destDir, filename);
+    if (!opts.dryRun) {
+        mkdirSync(destDir, { recursive: true });
+        writeFileSync(tarPath, gzipBytes);
+    }
+    return {
+        filename,
+        name,
+        version,
+        size: gzipBytes.byteLength,
+        unpackedSize,
+        shasum: sha1,
+        integrity,
+        entryCount: fileMetas.length,
+        files: fileMetas,
+        absolutePath: opts.dryRun ? null : tarPath,
+    };
+}
+/**
+ * Walk the workspace and return the list of files to include in the tarball,
+ * relative to `wsDir`. Mirrors npm pack's selection rules:
+ *
+ *   - If pkg.files exists: use it as an allowlist (with .npmignore as a
+ *     blacklist within those globs)
+ *   - Otherwise: walk everything, apply .npmignore + .gitignore, drop the
+ *     implicit-exclusion set (node_modules, .git, …)
+ *
+ * package.json, README*, LICENSE*, NOTICE* and the `bin`/`main` files are
+ * always force-included regardless of the rules above.
+ */
+function collectFiles(wsDir, pkg) {
+    const always = forceIncluded(pkg);
+    const filesField = Array.isArray(pkg.files) ? pkg.files.filter((f) => typeof f === 'string') : null;
+    let candidates;
+    if (filesField) {
+        candidates = expandFilesPatterns(wsDir, filesField);
+    }
+    else {
+        candidates = walkAll(wsDir);
+    }
+    const ignore = loadIgnore(wsDir);
+    const out = new Set();
+    for (const f of candidates) {
+        if (!ignore(f))
+            out.add(f);
+    }
+    for (const f of always) {
+        if (existsSync(join(wsDir, f)))
+            out.add(f);
+    }
+    return [...out].sort();
+}
+const ALWAYS_INCLUDED_BASENAMES = new Set(['package.json', 'README', 'README.md', 'LICENSE', 'LICENSE.md', 'NOTICE', 'NOTICE.md']);
+const NEVER_INCLUDED_BASENAMES = new Set([
+    '.git', '.svn', '.hg', '.gitignore', '.gitattributes', '.npmrc',
+    'CVS', '.DS_Store', 'node_modules', '.npmignore', 'package-lock.json',
+    'gjsify-lock.json', 'yarn.lock', 'yarn-error.log', '.yarn',
+    '.pnp.cjs', '.pnp.loader.mjs', 'tsconfig.tsbuildinfo',
+]);
+function forceIncluded(pkg) {
+    const out = new Set();
+    out.add('package.json');
+    for (const name of ['README', 'README.md', 'LICENSE', 'LICENSE.md', 'NOTICE', 'NOTICE.md']) {
+        out.add(name);
+    }
+    const main = typeof pkg.main === 'string' ? pkg.main : null;
+    if (main)
+        out.add(main.replace(/^\.\//, ''));
+    const bin = pkg.bin;
+    if (typeof bin === 'string') {
+        out.add(bin.replace(/^\.\//, ''));
+    }
+    else if (bin && typeof bin === 'object') {
+        for (const v of Object.values(bin)) {
+            if (typeof v === 'string')
+                out.add(v.replace(/^\.\//, ''));
+        }
+    }
+    return [...out];
+}
+function walkAll(root, sub = '') {
+    const out = [];
+    const here = sub ? join(root, sub) : root;
+    let entries;
+    try {
+        entries = readdirSync(here, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        if (NEVER_INCLUDED_BASENAMES.has(entry.name))
+            continue;
+        if (entry.name.startsWith('.tsbuildinfo'))
+            continue;
+        const rel = sub ? `${sub}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            out.push(...walkAll(root, rel));
+        }
+        else if (entry.isFile()) {
+            out.push(rel);
+        }
+    }
+    return out;
+}
+function expandFilesPatterns(wsDir, patterns) {
+    const out = new Set();
+    for (const pattern of patterns) {
+        // Drop leading ./
+        const normalized = pattern.replace(/^\.\//, '').replace(/\/$/, '');
+        const full = join(wsDir, normalized);
+        if (!existsSync(full))
+            continue;
+        const st = statSync(full);
+        if (st.isDirectory()) {
+            for (const f of walkAll(wsDir, normalized))
+                out.add(f);
+        }
+        else if (st.isFile()) {
+            out.add(normalized);
+        }
+        // TODO: glob patterns (foo/*.js). Currently we treat the entry as a
+        // literal file or directory. Most monorepos use file/dir entries only
+        // (lib, dist, prebuilds) — globs are rare. Surface a warning if the
+        // pattern contains glob chars and didn't resolve.
+        if (!existsSync(full) && /[*?[]/.test(pattern)) {
+            console.warn(`gjsify pack: files entry "${pattern}" looks like a glob but glob expansion isn't implemented — pass literal files/dirs`);
+        }
+    }
+    return [...out];
+}
+function loadIgnore(wsDir) {
+    // .npmignore takes precedence over .gitignore (npm semantics).
+    const npmIgnorePath = join(wsDir, '.npmignore');
+    const gitIgnorePath = join(wsDir, '.gitignore');
+    const patterns = [];
+    const sourcePath = existsSync(npmIgnorePath) ? npmIgnorePath : (existsSync(gitIgnorePath) ? gitIgnorePath : null);
+    if (sourcePath) {
+        const lines = readFileSync(sourcePath, 'utf-8').split('\n');
+        for (const raw of lines) {
+            const line = raw.trim();
+            if (!line || line.startsWith('#'))
+                continue;
+            // Simple translation: pattern → regex anchored to start, with `*` → `[^/]*`
+            // and `**` → `.*`. Negations (`!`) are skipped.
+            if (line.startsWith('!'))
+                continue;
+            patterns.push(globToRegex(line));
+        }
+    }
+    return (rel) => {
+        for (const p of patterns)
+            if (p.test(rel))
+                return true;
+        return false;
+    };
+}
+function globToRegex(glob) {
+    // Strip leading / (anchors to root)
+    let pat = glob.replace(/^\//, '');
+    // Escape regex metachars except *,?,/
+    pat = pat.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    // ** → .*  *  → [^/]*  ? → [^/]
+    pat = pat.replace(/\*\*/g, '__DOUBLESTAR__').replace(/\*/g, '[^/]*').replace(/__DOUBLESTAR__/g, '.*');
+    pat = pat.replace(/\?/g, '[^/]');
+    return new RegExp(`^${pat}($|/)`);
+}
+/**
+ * Walk pkg.dependencies / devDependencies / peerDependencies /
+ * optionalDependencies and replace `workspace:^` / `workspace:~` /
+ * `workspace:*` ranges with the resolved npm range based on each sibling
+ * workspace's version field.
+ */
+function rewriteWorkspaceDeps(pkg, wsDir) {
+    const root = findWorkspaceRoot(wsDir);
+    if (!root)
+        return pkg;
+    const siblings = new Map();
+    for (const ws of discoverWorkspaces(root)) {
+        if (ws.name && ws.version)
+            siblings.set(ws.name, ws.version);
+    }
+    const cloned = JSON.parse(JSON.stringify(pkg));
+    for (const block of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+        const deps = cloned[block];
+        if (!deps)
+            continue;
+        for (const [name, range] of Object.entries(deps)) {
+            if (typeof range !== 'string' || !range.startsWith('workspace:'))
+                continue;
+            const wsVer = siblings.get(name);
+            if (!wsVer) {
+                throw new Error(`gjsify pack: ${cloned.name} declares workspace:^ on ${name} but no sibling workspace with that name exists in the monorepo at ${root}`);
+            }
+            const operator = range.slice('workspace:'.length);
+            if (operator === '*' || operator === '') {
+                deps[name] = wsVer;
+            }
+            else if (operator === '^' || operator === '~') {
+                deps[name] = `${operator}${wsVer}`;
+            }
+            else {
+                deps[name] = operator;
+            }
+        }
+    }
+    return cloned;
+}
+function indentOf(source) {
+    const m = source.match(/\n([ \t]+)"/);
+    return m ? m[1] : '  ';
+}

package/lib/commands/publish.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../types/index.js';
+interface PublishOptions {
+    path?: string;
+    tag?: string;
+    access?: string;
+    'tolerate-republish'?: boolean;
+    provenance?: boolean;
+    'dry-run'?: boolean;
+    json?: boolean;
+}
+export declare const publishCommand: Command<any, PublishOptions>;
+export {};