@neon-rs/cli 0.0.1 → 0.0.3

package/dist/cargo.js

@@ -119,33 +119,28 @@ export class MessageStream {
         }
     }
 }
-export class CrossMessageStream extends MessageStream {
-    constructor(dir, file) {
+export class UnmountMessageStream extends MessageStream {
+    constructor(mount, manifestPath, file) {
         super(file);
-        this._dir = dir;
+        this._mount = mount;
+        this._manifestPath = manifestPath;
     }
     async findPath(pred) {
         // The base class's version reports paths as absolute paths from within
-        // the cross-rs Docker image's virtual filesystem.
-        const dockerPath = await super.findPath(pred);
-        if (!dockerPath) {
+        // a mount in a virtual filesystem.
+        const mountedPath = await super.findPath(pred);
+        if (!mountedPath) {
             return null;
         }
-        // Convert the absolute path into a relative path from within the
-        // workspace's target directory.
-        const cross = await execa('cross', ['metadata', '--format-version=1', '--no-deps'], {
-            cwd: this._dir,
-            shell: true
-        });
-        if (cross.exitCode !== 0) {
-            throw new Error(`Invoking \`cross metadata\` failed: ${cross.stderr}`);
-        }
-        const crossMetadata = JSON.parse(cross.stdout);
         // The path relative to the workspace's target directory.
-        const relPath = path.relative(crossMetadata.target_directory, dockerPath);
+        const relPath = path.relative(this._mount, mountedPath);
         // Now find the true absolute path of the target directory on the host system.
-        const cargo = await execa('cargo', ['metadata', '--format-version=1', '--no-deps'], {
-            cwd: this._dir,
+        const cargo = await execa('cargo', [
+            'metadata',
+            '--format-version=1',
+            '--no-deps',
+            ...(this._manifestPath ? ['--manifest-path', this._manifestPath] : [])
+        ], {
             shell: true
         });
         if (cargo.exitCode !== 0) {

package/dist/command.js

@@ -0,0 +1,39 @@
+import Dist from './commands/dist.js';
+import PackBuild from './commands/pack-build.js';
+import InstallBuilds from './commands/install-builds.js';
+import Help from './commands/help.js';
+export var CommandName;
+(function (CommandName) {
+    CommandName["Help"] = "help";
+    CommandName["Dist"] = "dist";
+    CommandName["PackBuild"] = "pack-build";
+    CommandName["InstallBuilds"] = "install-builds";
+})(CommandName = CommandName || (CommandName = {}));
+;
+export function isCommandName(s) {
+    const keys = Object.values(CommandName);
+    return keys.includes(s);
+}
+export function asCommandName(name) {
+    if (!isCommandName(name)) {
+        throw new RangeError(`Command not recognized: ${name}`);
+    }
+    return name;
+}
+const COMMANDS = {
+    [CommandName.Help]: Help,
+    [CommandName.Dist]: Dist,
+    [CommandName.PackBuild]: PackBuild,
+    [CommandName.InstallBuilds]: InstallBuilds
+};
+export function commandFor(name) {
+    return COMMANDS[name];
+}
+export function summaries() {
+    return [
+        { name: CommandName.Help, summary: Help.summary() },
+        { name: CommandName.Dist, summary: Dist.summary() },
+        { name: CommandName.PackBuild, summary: PackBuild.summary() },
+        { name: CommandName.InstallBuilds, summary: InstallBuilds.summary() }
+    ];
+}

package/dist/commands/dist.js

@@ -1,38 +1,75 @@
 import { copyFile } from 'node:fs/promises';
 import commandLineArgs from 'command-line-args';
-import { MessageStream, isCompilerArtifact } from '../cargo.js';
+import { MessageStream, UnmountMessageStream, isCompilerArtifact } from '../cargo.js';
 // FIXME: add options to infer crate name from manifests
 // --package <path/to/package.json>
 // --crate <path/to/Cargo.toml>
 const OPTIONS = [
     { name: 'name', alias: 'n', type: String, defaultValue: null },
-    { name: 'log', alias: 'l', type: String, defaultValue: null },
     { name: 'file', alias: 'f', type: String, defaultValue: null },
+    { name: 'log', alias: 'l', type: String, defaultValue: null },
+    { name: 'mount', alias: 'm', type: String, defaultValue: null },
+    { name: 'manifest-path', type: String, defaultValue: null },
     { name: 'out', alias: 'o', type: String, defaultValue: 'index.node' }
 ];
-async function findArtifact(log, crateName) {
-    const stream = new MessageStream(log);
-    return await stream.findPath((msg) => {
-        if (!isCompilerArtifact(msg) || (msg.target.name !== crateName)) {
-            return null;
+export default class Dist {
+    static summary() { return 'Generate a .node file from a build.'; }
+    static syntax() { return 'neon dist [-n <name>] [-f <dylib>|[-l <log>] [-m <path>]] [-o <dist>]'; }
+    static options() {
+        return [
+            { name: '-n, --name', summary: 'Crate name. (Default: $npm_package_name)' },
+            { name: '-f, --file <dylib>', summary: 'Build .node from dylib file <dylib>.' },
+            { name: '-l, --log <log>', summary: 'Find dylib path from cargo messages <log>. (Default: stdin)' },
+            {
+                name: '-m, --mount <path>',
+                summary: 'Mounted path of target directory in virtual filesystem. This is used to map paths from the log data back to their real paths, needed when tools such as cross-rs report messages from within a mounted Docker filesystem.'
+            },
+            { name: '--manifest-path <path>', summary: 'Real path to Cargo.toml. (Default: cargo behavior)' },
+            { name: '-o, --out <dist>', summary: 'Copy output to file <dist>. (Default: index.node)' }
+        ];
+    }
+    static seeAlso() {
+        return [
+            { name: 'cargo messages', summary: '<https://doc.rust-lang.org/cargo/reference/external-tools.html>' },
+            { name: 'cross-rs', summary: '<https://github.com/cross-rs/cross>' }
+        ];
+    }
+    constructor(argv) {
+        const options = commandLineArgs(OPTIONS, { argv });
+        if (options.log && options.file) {
+            throw new Error("Options --log and --file cannot both be enabled.");
         }
-        const index = msg.target.crate_types.indexOf('cdylib');
-        return (index < 0) ? null : msg.filenames[index];
-    });
-}
-export default async function main(argv) {
-    const options = commandLineArgs(OPTIONS, { argv });
-    if (options.log && options.file) {
-        throw new Error("Options --log and --file cannot both be enabled.");
+        if (options.file && options.mount) {
+            throw new Error("Options --mount and --file cannot both be enabled.");
+        }
+        if (options['manifest-path'] && !options.mount) {
+            throw new Error("Option --manifest-path requires option --mount to be provided.");
+        }
+        this._log = options.log ?? null;
+        this._file = options.file ?? null;
+        this._mount = options.mount;
+        this._manifestPath = options['manifest-path'];
+        this._crateName = options.name || process.env['npm_package_name'];
+        this._out = options.out;
     }
-    const crateName = options.name || process.env['npm_package_name'];
-    if (!crateName) {
-        throw new Error("No crate name provided.");
+    async findArtifact() {
+        const stream = this._mount
+            ? new UnmountMessageStream(this._mount, this._manifestPath, this._log)
+            : new MessageStream(this._log);
+        return await stream.findPath((msg) => {
+            if (!isCompilerArtifact(msg) || (msg.target.name !== this._crateName)) {
+                return null;
+            }
+            const index = msg.target.crate_types.indexOf('cdylib');
+            return (index < 0) ? null : msg.filenames[index];
+        });
     }
-    const file = options.file ?? await findArtifact(options.log, crateName);
-    if (!file) {
-        throw new Error(`No library found for crate ${crateName}`);
+    async run() {
+        const file = this._file || await this.findArtifact();
+        if (!file) {
+            throw new Error(`No library found for crate ${this._crateName}`);
+        }
+        // FIXME: needs all the logic of cargo-cp-artifact (timestamp check, M1 workaround, async, errors)
+        await copyFile(file, this._out);
     }
-    // FIXME: needs all the logic of cargo-cp-artifact (timestamp check, M1 workaround, async, errors)
-    await copyFile(file, options.out);
 }

package/dist/commands/help.js

@@ -0,0 +1,26 @@
+import { printMainUsage, printCommandUsage } from '../print.js';
+import { asCommandName } from '../command.js';
+export default class Help {
+    static summary() { return 'Display help information about Neon.'; }
+    static syntax() { return 'neon help <command>'; }
+    static options() {
+        return [
+            { name: '<command>', summary: 'Command to display help information about.' }
+        ];
+    }
+    static seeAlso() { }
+    constructor(argv) {
+        this._name = argv.length > 0 ? asCommandName(argv[0]) : undefined;
+        if (argv.length > 1) {
+            throw new Error(`Unexpected argument: ${argv[1]}`);
+        }
+    }
+    async run() {
+        if (this._name) {
+            printCommandUsage(this._name);
+        }
+        else {
+            printMainUsage();
+        }
+    }
+}

package/dist/commands/install-builds.js

@@ -0,0 +1,65 @@
+import { execa } from 'execa';
+import commandLineArgs from 'command-line-args';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+const OPTIONS = [
+    { name: 'bundle', alias: 'b', type: String, defaultValue: null },
+    { name: 'no-bundle', alias: 'B', type: String, defaultValue: null }
+];
+export default class InstallBuilds {
+    static summary() { return 'Install dependencies on prebuilds in package.json.'; }
+    static syntax() { return 'neon install-builds [-b <file>|-B]'; }
+    static options() {
+        return [
+            { name: '-b, --bundle <file>', summary: 'File to generate bundling metadata. (Default: .targets)' },
+            {
+                name: '',
+                summary: 'This generated file ensures support for bundlers (e.g. @vercel/ncc), which rely on static analysis to detect and enable any addons used by the library.'
+            },
+            { name: '-B, --no-bundle', summary: 'Do not generate bundling metadata.' }
+        ];
+    }
+    static seeAlso() {
+        return [
+            { name: 'ncc', summary: '<https://github.com/vercel/ncc>' }
+        ];
+    }
+    constructor(argv) {
+        const options = commandLineArgs(OPTIONS, { argv });
+        if (options.bundle && options['no-bundle']) {
+            throw new Error("Options --bundle and --no-bundle cannot both be enabled.");
+        }
+        this._bundle = options['no-bundle']
+            ? null
+            : !options.bundle
+                ? '.targets'
+                : options.bundle;
+    }
+    async run() {
+        const manifest = JSON.parse(await fs.readFile(path.join(process.cwd(), 'package.json'), { encoding: 'utf8' }));
+        const version = manifest.version;
+        const targets = Object.values(manifest.neon.targets);
+        const specs = targets.map(name => `${name}@${version}`);
+        const result = await execa('npm', ['install', '--save-exact', '-O', ...specs], { shell: true });
+        if (result.exitCode !== 0) {
+            console.error(result.stderr);
+            process.exit(result.exitCode);
+        }
+        if (!this._bundle) {
+            return;
+        }
+        const PREAMBLE = `// AUTOMATICALLY GENERATED FILE. DO NOT EDIT.
+//
+// This code is never executed but is detected by the static analysis of
+// bundlers such as \`@vercel/ncc\`. The require() expression that selects
+// the right binary module for the current platform is too dynamic to be
+// analyzable by bundler analyses, so this module provides an exhaustive
+// static list for those analyses.
+
+return;
+
+`;
+        const requires = targets.map(name => `require('${name}');`).join('\n');
+        await fs.writeFile(this._bundle, PREAMBLE + requires + '\n');
+    }
+}

package/dist/commands/pack-build.js

@@ -0,0 +1,106 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { createRequire } from 'node:module';
+import * as temp from 'temp';
+import commandLineArgs from 'command-line-args';
+import { execa } from 'execa';
+const mktemp = temp.track().mkdir;
+const OPTIONS = [
+    { name: 'file', alias: 'f', type: String, defaultValue: 'index.node' },
+    { name: 'out-dir', alias: 'd', type: String, defaultValue: null }
+];
+const require = createRequire(import.meta.url);
+const LLVM = require('../../data/llvm.json');
+const NODE = require('../../data/node.json');
+function lookup(target) {
+    const path = LLVM[target];
+    if (!path) {
+        throw new Error(`Rust target ${target} not supported`);
+    }
+    const [platform, arch, abi] = path;
+    return NODE[platform][arch][abi];
+}
+export default class PackBuild {
+    static summary() { return 'Create an npm tarball from a prebuild.'; }
+    static syntax() { return 'neon pack-build [-f <addon>] [-t <target>]'; }
+    static options() {
+        return [
+            { name: '-f, --file <addon>', summary: 'Prebuilt .node file to pack. (Default: index.node)' },
+            { name: '-t, --target <target>', summary: 'Rust target triple the addon was built for. (Default: rustc default host)' }
+        ];
+    }
+    static seeAlso() {
+        return [
+            { name: 'Rust platform support', summary: '<https://doc.rust-lang.org/rustc/platform-support.html>' },
+            { name: 'npm pack', summary: '<https://docs.npmjs.com/cli/commands/npm-pack>' },
+            { name: 'cross-rs', summary: '<https://github.com/cross-rs/cross>' }
+        ];
+    }
+    constructor(argv) {
+        const options = commandLineArgs(OPTIONS, { argv });
+        this._target = options.target || null;
+        this._addon = options.file;
+        this._outDir = options['out-dir'] || path.join(process.cwd(), 'dist');
+    }
+    async currentTarget() {
+        const result = await execa("rustc", ["-vV"], { shell: true });
+        if (result.exitCode !== 0) {
+            throw new Error(`Could not determine current Rust target: ${result.stderr}`);
+        }
+        const hostLine = result.stdout.split(/\n/).find(line => line.startsWith('host:'));
+        if (!hostLine) {
+            throw new Error("Could not determine current Rust target (unexpected rustc output)");
+        }
+        return hostLine.replace(/^host:\s+/, '');
+    }
+    async run() {
+        await fs.mkdir(this._outDir, { recursive: true });
+        const manifest = JSON.parse(await fs.readFile('package.json', { encoding: 'utf8' }));
+        const version = manifest.version;
+        const targets = manifest.neon.targets;
+        const target = this._target || await this.currentTarget();
+        const name = targets[target];
+        if (!name) {
+            throw new Error(`Rust target ${target} not found in package.json.`);
+        }
+        const targetInfo = lookup(target);
+        const description = `Prebuilt binary package for \`${manifest.name}\` on \`${targetInfo.node}\`.`;
+        let prebuildManifest = {
+            name,
+            description,
+            version,
+            os: [targetInfo.platform],
+            cpu: [targetInfo.arch],
+            main: "index.node",
+            files: ["README.md", "index.node"]
+        };
+        const OPTIONAL_KEYS = [
+            'author', 'repository', 'keywords', 'bugs', 'homepage', 'license', 'engines'
+        ];
+        for (const key of OPTIONAL_KEYS) {
+            if (manifest[key]) {
+                prebuildManifest[key] = manifest[key];
+            }
+        }
+        const tmpdir = await mktemp('neon-');
+        await fs.writeFile(path.join(tmpdir, "package.json"), JSON.stringify(prebuildManifest, null, 2));
+        await fs.copyFile(this._addon, path.join(tmpdir, "index.node"));
+        await fs.writeFile(path.join(tmpdir, "README.md"), `# \`${name}\`\n\n${description}\n`);
+        const result = await execa("npm", ["pack", "--json"], {
+            shell: true,
+            cwd: tmpdir,
+            stdio: ['pipe', 'pipe', 'inherit']
+        });
+        if (result.exitCode !== 0) {
+            process.exit(result.exitCode);
+        }
+        // FIXME: comment linking to the npm issue this fixes
+        const tarball = JSON.parse(result.stdout)[0].filename.replace('@', '').replace('/', '-');
+        const dest = path.join(this._outDir, tarball);
+        // Copy instead of move since e.g. GitHub Actions Windows runners host temp directories
+        // on a different device (which causes fs.renameSync to fail).
+        await fs.copyFile(path.join(tmpdir, tarball), dest);
+        console.log(dest);
+    }
+    ;
+}

package/dist/index.js

@@ -1,52 +1,33 @@
 #!/usr/bin/env node
 import commandLineCommands from 'command-line-commands';
-import { printUsage, die } from './usage.js';
-import dist from './commands/dist.js';
-import crossDist from './commands/cross-dist.js';
-import crossPack from './commands/cross-pack.js';
-import crossInstall from './commands/cross-install.js';
-const VALID_COMMANDS = [null, 'help', 'dist', 'cross-dist', 'cross-pack', 'cross-install'];
-export function expectCommandName(name) {
-    switch (name) {
-        case 'help':
-        case 'dist':
-        case 'cross-dist':
-        case 'cross-pack':
-        case 'cross-install':
-            return name;
-        default:
-            throw new RangeError(`Unrecognized command: ${name}`);
+import { printErrorWithUsage, printError, printMainUsage } from './print.js';
+import { CommandName, asCommandName, commandFor } from './command.js';
+class Cli {
+    parse() {
+        try {
+            const { command, argv } = commandLineCommands([null, ...Object.values(CommandName)]);
+            if (!command) {
+                printMainUsage();
+                process.exit(0);
+            }
+            const ctor = commandFor(asCommandName(command));
+            return new ctor(argv);
+        }
+        catch (e) {
+            printErrorWithUsage(e);
+            process.exit(1);
+        }
     }
 }
 async function main() {
+    const cli = new Cli();
+    const command = cli.parse();
     try {
-        const { command, argv } = commandLineCommands(VALID_COMMANDS);
-        switch (command) {
-            case 'dist':
-                await dist(argv);
-                break;
-            case 'cross-dist':
-                await crossDist(argv);
-                break;
-            case 'cross-pack':
-                await crossPack(argv);
-                break;
-            case 'cross-install':
-                await crossInstall(argv);
-                break;
-            case 'help':
-                if (argv.length > 0) {
-                    printUsage(expectCommandName(argv[0]));
-                    process.exit(0);
-                }
-            // FALL THROUGH
-            case null:
-                printUsage();
-        }
-        process.exit(0);
+        await command.run();
     }
     catch (e) {
-        die((e instanceof Error) ? e.message : null);
+        printError(e);
+        process.exit(1);
     }
 }
 main();

package/dist/print.js

@@ -0,0 +1,69 @@
+import commandLineUsage from 'command-line-usage';
+import chalk from 'chalk';
+import { commandFor, summaries } from './command.js';
+function pink(text) {
+    return chalk.bold.hex('#e75480')(text);
+}
+function blue(text) {
+    return chalk.bold.cyanBright(text);
+}
+function yellow(text) {
+    return chalk.bold.yellowBright(text);
+}
+function green(text) {
+    return chalk.bold.greenBright(text);
+}
+function commandUsage(name, command) {
+    const sections = [
+        {
+            content: `${pink('Neon:')} ${name} - ${command.summary()}`,
+            raw: true
+        },
+        {
+            header: blue('Usage:'),
+            content: `${blue('$')} ${command.syntax()}`
+        },
+        {
+            header: yellow('Options:'),
+            content: command.options()
+        }
+    ];
+    const seeAlso = command.seeAlso();
+    if (seeAlso) {
+        sections.push({ header: green('See Also:'), content: seeAlso });
+    }
+    return commandLineUsage(sections).trimStart();
+}
+function mainUsage() {
+    const sections = [
+        {
+            content: `${pink('Neon:')} the npm packaging tool for Rust addons`,
+            raw: true
+        },
+        {
+            header: blue('Usage:'),
+            content: `${blue('$')} neon <command> <options>`
+        },
+        {
+            header: yellow('Commands:'),
+            content: summaries()
+        }
+    ];
+    return commandLineUsage(sections).trim();
+}
+export function printCommandUsage(name) {
+    console.error(commandUsage(name, commandFor(name)));
+}
+export function printMainUsage() {
+    console.error(mainUsage());
+    console.error();
+    console.error("See 'neon help <command>' for more information on a specific command.");
+}
+export function printErrorWithUsage(e) {
+    console.error(mainUsage());
+    console.error();
+    printError(e);
+}
+export function printError(e) {
+    console.error(chalk.bold.red("error:") + " " + ((e instanceof Error) ? e.message : String(e)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neon-rs/cli",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Command-line build tool for Neon modules.",
   "type": "module",
   "exports": "./dist/index.js",

package/types/cargo.d.ts

@@ -35,8 +35,9 @@ export declare class MessageStream {
     constructor(file?: string | null);
     findPath(pred: MessageFilter<string>): Promise<string | null>;
 }
-export declare class CrossMessageStream extends MessageStream {
-    private _dir;
-    constructor(dir: string, file?: string | null);
+export declare class UnmountMessageStream extends MessageStream {
+    private _mount;
+    private _manifestPath;
+    constructor(mount: string, manifestPath: string | null, file?: string | null);
     findPath(pred: MessageFilter<string>): Promise<string | null>;
 }

package/types/command.d.ts

@@ -0,0 +1,24 @@
+export interface Command {
+    run(): Promise<void>;
+}
+export interface CommandStatics {
+    summary(): string;
+    syntax(): string;
+    options(): CommandDetail[];
+    seeAlso(): CommandDetail[] | void;
+}
+export type CommandClass = (new (argv: string[]) => Command) & CommandStatics;
+export type CommandDetail = {
+    name: string;
+    summary: string;
+};
+export declare enum CommandName {
+    Help = "help",
+    Dist = "dist",
+    PackBuild = "pack-build",
+    InstallBuilds = "install-builds"
+}
+export declare function isCommandName(s: string): s is CommandName;
+export declare function asCommandName(name: string): CommandName;
+export declare function commandFor(name: CommandName): CommandClass;
+export declare function summaries(): CommandDetail[];

package/types/commands/cross-dist.d.ts

@@ -1 +1,14 @@
-export default function main(argv: string[]): Promise<void>;
+import { Command, CommandDetail } from '../command.js';
+export default class CrossDist implements Command {
+    static summary(): string;
+    static syntax(): string;
+    static options(): CommandDetail[];
+    static seeAlso(): CommandDetail[] | void;
+    private _file;
+    private _log;
+    private _crateName;
+    private _dir;
+    private _out;
+    constructor(argv: string[]);
+    run(): Promise<void>;
+}

package/types/commands/cross-install.d.ts

@@ -1 +1,10 @@
-export default function main(argv: string[]): Promise<void>;
+import { Command, CommandDetail } from '../command.js';
+export default class CrossInstall implements Command {
+    static summary(): string;
+    static syntax(): string;
+    static options(): CommandDetail[];
+    static seeAlso(): CommandDetail[] | void;
+    private _bundle;
+    constructor(argv: string[]);
+    run(): Promise<void>;
+}

package/types/commands/cross-pack.d.ts

@@ -1 +1,12 @@
-export default function main(argv: string[]): Promise<void>;
+import { Command, CommandDetail } from '../command.js';
+export default class CrossPack implements Command {
+    static summary(): string;
+    static syntax(): string;
+    static options(): CommandDetail[];
+    static seeAlso(): CommandDetail[] | void;
+    private _target;
+    private _addon;
+    private _outDir;
+    constructor(argv: string[]);
+    run(): Promise<void>;
+}

package/types/commands/dist.d.ts

@@ -1 +1,16 @@
-export default function main(argv: string[]): Promise<void>;
+import { Command, CommandDetail } from '../command.js';
+export default class Dist implements Command {
+    static summary(): string;
+    static syntax(): string;
+    static options(): CommandDetail[];
+    static seeAlso(): CommandDetail[] | void;
+    private _log;
+    private _file;
+    private _mount;
+    private _manifestPath;
+    private _crateName;
+    private _out;
+    constructor(argv: string[]);
+    findArtifact(): Promise<string | null>;
+    run(): Promise<void>;
+}

package/types/commands/help.d.ts

@@ -0,0 +1,10 @@
+import { Command, CommandDetail } from '../command.js';
+export default class Help implements Command {
+    static summary(): string;
+    static syntax(): string;
+    static options(): CommandDetail[];
+    static seeAlso(): CommandDetail[] | void;
+    private _name?;
+    constructor(argv: string[]);
+    run(): Promise<void>;
+}

package/types/commands/install-builds.d.ts

@@ -0,0 +1,10 @@
+import { Command, CommandDetail } from '../command.js';
+export default class InstallBuilds implements Command {
+    static summary(): string;
+    static syntax(): string;
+    static options(): CommandDetail[];
+    static seeAlso(): CommandDetail[] | void;
+    private _bundle;
+    constructor(argv: string[]);
+    run(): Promise<void>;
+}

package/types/commands/pack-build.d.ts

@@ -0,0 +1,13 @@
+import { Command, CommandDetail } from '../command.js';
+export default class PackBuild implements Command {
+    static summary(): string;
+    static syntax(): string;
+    static options(): CommandDetail[];
+    static seeAlso(): CommandDetail[] | void;
+    private _target;
+    private _addon;
+    private _outDir;
+    constructor(argv: string[]);
+    currentTarget(): Promise<string>;
+    run(): Promise<void>;
+}

package/types/index.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
-export type CommandName = 'help' | 'dist' | 'cross-dist' | 'cross-pack' | 'cross-install';
-export declare function expectCommandName(name: string): CommandName;
+export {};

package/types/print.d.ts

@@ -0,0 +1,5 @@
+import { CommandName } from './command.js';
+export declare function printCommandUsage(name: CommandName): void;
+export declare function printMainUsage(): void;
+export declare function printErrorWithUsage(e: any): void;
+export declare function printError(e: any): void;

package/types/usage.d.ts

@@ -1,3 +1,2 @@
 import type { CommandName } from './index.js';
 export declare function printUsage(command?: CommandName): void;
-export declare function die(msg?: string | null): void;

package/dist/commands/cross-dist.js

@@ -1,40 +0,0 @@
-import { copyFile } from 'node:fs/promises';
-import commandLineArgs from 'command-line-args';
-import { CrossMessageStream, isCompilerArtifact } from '../cargo.js';
-// FIXME: add options to infer crate name from manifests
-// --package <path/to/package.json>
-// --crate <path/to/Cargo.toml>
-const OPTIONS = [
-    { name: 'name', alias: 'n', type: String, defaultValue: null },
-    { name: 'log', alias: 'l', type: String, defaultValue: null },
-    { name: 'dir', alias: 'd', type: String, defaultValue: null },
-    { name: 'file', alias: 'f', type: String, defaultValue: null },
-    { name: 'out', alias: 'o', type: String, defaultValue: 'index.node' }
-];
-async function findArtifact(log, crateName, dir) {
-    const stream = new CrossMessageStream(dir, log);
-    return await stream.findPath((msg) => {
-        if (!isCompilerArtifact(msg) || (msg.target.name !== crateName)) {
-            return null;
-        }
-        const index = msg.target.crate_types.indexOf('cdylib');
-        return (index < 0) ? null : msg.filenames[index];
-    });
-}
-export default async function main(argv) {
-    const options = commandLineArgs(OPTIONS, { argv });
-    if (options.log && options.file) {
-        throw new Error("Options --log and --file cannot both be enabled.");
-    }
-    const crateName = options.name || process.env['npm_package_name'];
-    if (!crateName) {
-        throw new Error("No crate name provided.");
-    }
-    const dir = options.dir || process.cwd();
-    const file = options.file ?? await findArtifact(options.log, crateName, dir);
-    if (!file) {
-        throw new Error(`No library found for crate ${crateName}`);
-    }
-    // FIXME: needs all the logic of cargo-cp-artifact (timestamp check, M1 workaround, async, errors)
-    await copyFile(file, options.out);
-}

package/dist/commands/cross-install.js

@@ -1,42 +0,0 @@
-import { execa } from 'execa';
-import commandLineArgs from 'command-line-args';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-const OPTIONS = [
-    { name: 'bundle', alias: 'b', type: String, defaultValue: null },
-    { name: 'no-bundle', alias: 'B', type: String, defaultValue: null }
-];
-export default async function main(argv) {
-    const options = commandLineArgs(OPTIONS, { argv });
-    if (options.bundle && options['no-bundle']) {
-        throw new Error("Options --bundle and --no-bundle cannot both be enabled.");
-    }
-    if (!options.bundle && !options['no-bundle']) {
-        options.bundle = '.targets';
-    }
-    const manifest = JSON.parse(await fs.readFile(path.join(process.cwd(), 'package.json'), { encoding: 'utf8' }));
-    const version = manifest.version;
-    const targets = Object.values(manifest.neon.targets);
-    const specs = targets.map(name => `${name}@${version}`);
-    const result = await execa('npm', ['install', '--save-exact', '-O', ...specs], { shell: true });
-    if (result.exitCode !== 0) {
-        console.error(result.stderr);
-        process.exit(result.exitCode);
-    }
-    if (!options.bundle) {
-        return;
-    }
-    const PREAMBLE = `// AUTOMATICALLY GENERATED FILE. DO NOT EDIT.
-//
-// This code is never executed but is detected by the static analysis of
-// bundlers such as \`@vercel/ncc\`. The require() expression that selects
-// the right binary module for the current platform is too dynamic to be
-// analyzable by bundler analyses, so this module provides an exhaustive
-// static list for those analyses.
-
-return;
-
-`;
-    const requires = targets.map(name => `require('${name}');`).join('\n');
-    await fs.writeFile(options.bundle, PREAMBLE + requires + '\n');
-}

package/dist/commands/cross-pack.js

@@ -1,81 +0,0 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { createRequire } from 'node:module';
-import * as temp from 'temp';
-import commandLineArgs from 'command-line-args';
-import { execa } from 'execa';
-const mktemp = temp.track().mkdir;
-const OPTIONS = [
-    { name: 'file', alias: 'f', type: String, defaultValue: 'index.node' },
-    { name: 'out-dir', alias: 'd', type: String, defaultValue: null }
-];
-const require = createRequire(import.meta.url);
-const LLVM = require('../../data/llvm.json');
-const NODE = require('../../data/node.json');
-function lookup(target) {
-    const path = LLVM[target];
-    if (!path) {
-        throw new Error(`Rust target ${target} not supported`);
-    }
-    const [platform, arch, abi] = path;
-    return NODE[platform][arch][abi];
-}
-export default async function main(argv) {
-    const options = commandLineArgs(OPTIONS, { argv, stopAtFirstUnknown: true });
-    argv = options._unknown || [];
-    if (argv.length === 0) {
-        throw new Error("Expected <target>.");
-    }
-    if (argv.length > 1) {
-        throw new Error(`Unexpected argument \`${argv[1]}\`.`);
-    }
-    const target = argv[0];
-    const addon = options.file;
-    const outDir = options['out-dir'] || path.join(process.cwd(), 'dist');
-    await fs.mkdir(outDir, { recursive: true });
-    const manifest = JSON.parse(await fs.readFile('package.json', { encoding: 'utf8' }));
-    const version = manifest.version;
-    const targets = manifest.neon.targets;
-    const name = targets[target];
-    if (!name) {
-        throw new Error(`Rust target ${target} not found in package.json.`);
-    }
-    const targetInfo = lookup(target);
-    const description = `Prebuilt binary package for \`${manifest.name}\` on \`${targetInfo.node}\`.`;
-    let prebuildManifest = {
-        name,
-        description,
-        version,
-        os: [targetInfo.platform],
-        cpu: [targetInfo.arch],
-        main: "index.node",
-        files: ["README.md", "index.node"]
-    };
-    const OPTIONAL_KEYS = [
-        'author', 'repository', 'keywords', 'bugs', 'homepage', 'license', 'engines'
-    ];
-    for (const key of OPTIONAL_KEYS) {
-        if (manifest[key]) {
-            prebuildManifest[key] = manifest[key];
-        }
-    }
-    const tmpdir = await mktemp('neon-');
-    await fs.writeFile(path.join(tmpdir, "package.json"), JSON.stringify(prebuildManifest, null, 2));
-    await fs.copyFile(addon, path.join(tmpdir, "index.node"));
-    await fs.writeFile(path.join(tmpdir, "README.md"), `# \`${name}\`\n\n${description}\n`);
-    const result = await execa("npm", ["pack", "--json"], {
-        shell: true,
-        cwd: tmpdir,
-        stdio: ['pipe', 'pipe', 'inherit']
-    });
-    if (result.exitCode !== 0) {
-        process.exit(result.exitCode);
-    }
-    // FIXME: comment linking to the npm issue this fixes
-    const tarball = JSON.parse(result.stdout)[0].filename.replace('@', '').replace('/', '-');
-    const dest = path.join(outDir, tarball);
-    // Copy instead of move since e.g. GitHub Actions Windows runners host temp directories
-    // on a different device (which causes fs.renameSync to fail).
-    await fs.copyFile(path.join(tmpdir, tarball), dest);
-    console.log(dest);
-}

package/dist/usage.js

@@ -1,150 +0,0 @@
-import { createRequire } from 'node:module';
-import commandLineUsage from 'command-line-usage';
-import chalk from 'chalk';
-function pink(text) {
-    return chalk.bold.hex('#e75480')(text);
-}
-function blue(text) {
-    return chalk.bold.cyanBright(text);
-}
-function yellow(text) {
-    return chalk.bold.yellowBright(text);
-}
-function green(text) {
-    return chalk.bold.greenBright(text);
-}
-function commandUsage(name, command) {
-    const sections = [
-        {
-            content: `${pink('Neon:')} ${name} - ${COMMAND_SUMMARIES[name]}`,
-            raw: true
-        },
-        {
-            header: blue('Usage:'),
-            content: `${blue('$')} ${command.syntax}`
-        },
-        {
-            header: yellow('Options:'),
-            content: command.options
-        }
-    ];
-    if (command.seeAlso) {
-        sections.push({
-            header: green('See Also:'),
-            content: command.seeAlso
-        });
-    }
-    return commandLineUsage(sections);
-}
-function mainUsage() {
-    const require = createRequire(import.meta.url);
-    const version = require('../package.json').version;
-    const sections = [
-        {
-            content: `${pink('Neon:')} CLI v${version}`,
-            raw: true
-        },
-        {
-            header: blue('Usage:'),
-            content: `${blue('$')} neon <command> <options>`
-        },
-        {
-            header: yellow('Commands:'),
-            content: [
-                { name: 'help', summary: COMMAND_SUMMARIES['help'] + '.' },
-                { name: 'dist', summary: COMMAND_SUMMARIES['dist'] + '.' },
-                { name: 'cross-dist', summary: COMMAND_SUMMARIES['cross-dist'] + '.' },
-                { name: 'cross-pack', summary: COMMAND_SUMMARIES['cross-pack'] + '.' },
-                { name: 'cross-install', summary: COMMAND_SUMMARIES['cross-install'] + '.' }
-            ]
-        }
-    ];
-    return commandLineUsage(sections);
-}
-const COMMAND_SUMMARIES = {
-    'help': 'Display help information about Neon',
-    'dist': 'Generate a .node file from a build',
-    'cross-dist': 'Generate a .node file from a cross-compiled prebuild',
-    'cross-pack': 'Create an npm tarball from a cross-compiled prebuild',
-    'cross-install': 'Install dependencies on cross-compiled prebuilds'
-};
-const COMMAND_USAGES = {
-    'help': {
-        syntax: 'neon help <command>',
-        options: [
-            { name: '<command>', summary: 'Command to display help information about.' }
-        ]
-    },
-    'dist': {
-        syntax: 'neon dist [-n <name>] [-l <log>|-f <dylib>] [-o <dist>]',
-        options: [
-            { name: '-n, --name', summary: 'Crate name. (Default: $npm_package_name)' },
-            { name: '-l, --log <log>', summary: 'Find dylib path from cargo messages <log>. (Default: stdin)' },
-            { name: '-f, --file <dylib>', summary: 'Build .node from dylib file <dylib>.' },
-            { name: '-o, --out <dist>', summary: 'Copy output to file <dist>. (Default: index.node)' }
-        ],
-        seeAlso: [
-            { name: 'cargo messages', summary: '<https://doc.rust-lang.org/cargo/reference/external-tools.html>' }
-        ]
-    },
-    'cross-dist': {
-        syntax: 'neon cross-dist [-n <name>] [-l <log>|-f <dylib>] [-d <dir>] [-o <dist>]',
-        options: [
-            { name: '-n, --name', summary: 'Crate name. (Default: $npm_package_name)' },
-            { name: '-l, --log <log>', summary: 'Find dylib path from cargo messages <log>. (Default: stdin)' },
-            { name: '-d, --dir <dir>', summary: 'Crate workspace root directory. (Default: .)' },
-            {
-                name: '',
-                summary: 'This is needed to normalize paths from the log data, which cross-rs provides from within the mounted Docker filesystem, back to the host filesystem.'
-            },
-            { name: '-f, --file <dylib>', summary: 'Build .node from dylib file <dylib>.' },
-            { name: '-o, --out <dist>', summary: 'Copy output to file <dist>. (Default: index.node)' }
-        ],
-        seeAlso: [
-            { name: 'cargo messages', summary: '<https://doc.rust-lang.org/cargo/reference/external-tools.html>' },
-            { name: 'cross-rs', summary: '<https://github.com/cross-rs/cross>' }
-        ]
-    },
-    'cross-pack': {
-        syntax: 'neon cross-pack [-f <addon>] <target>',
-        options: [
-            { name: '-f, --file <addon>', summary: 'Prebuilt .node file to pack. (Default: index.node)' },
-            { name: '<target>', summary: 'Rust target triple the addon was built for.' }
-        ],
-        seeAlso: [
-            { name: 'Rust platform support', summary: '<https://doc.rust-lang.org/rustc/platform-support.html>' },
-            { name: 'npm pack', summary: '<https://docs.npmjs.com/cli/commands/npm-pack>' },
-            { name: 'cross-rs', summary: '<https://github.com/cross-rs/cross>' }
-        ]
-    },
-    'cross-install': {
-        syntax: 'neon cross-install [-b <file>|-B]',
-        options: [
-            { name: '-b, --bundle <file>', summary: 'File to generate bundling metadata. (Default: .targets)' },
-            {
-                name: '',
-                summary: 'This generated file ensures support for bundlers (e.g. @vercel/ncc), which rely on static analysis to detect and enable any addons used by the library.'
-            },
-            { name: '-B, --no-bundle', summary: 'Do not generate bundling metadata.' }
-        ],
-        seeAlso: [
-            { name: 'ncc', summary: '<https://github.com/vercel/ncc>' }
-        ]
-    }
-};
-export function printUsage(command) {
-    if (command) {
-        console.error(commandUsage(command, COMMAND_USAGES[command]));
-    }
-    else {
-        console.error(mainUsage());
-    }
-}
-export function die(msg) {
-    printUsage();
-    if (msg) {
-        console.error();
-        console.error(msg);
-    }
-    process.exit(1);
-}