@neon-rs/cli 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 David Herman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LICENSE.triples.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 LongYinan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,10 @@
+# `@neon-rs/cli`
+
+A command-line tool for packaging and distributing Neon projects.
+
+## License
+
+This tool is provided under the MIT license.
+
+Includes other software related under the MIT license:
+- The file `node.json` is derived from [@napi-rs/triples](https://github.com/napi-rs/napi-rs/tree/main/triples) (see `LICENSE-triples.txt`).

package/data/llvm.json

@@ -0,0 +1,42 @@
+{
+  "aarch64-apple-darwin": ["darwin", "arm64", 0],
+  "x86_64-apple-darwin": ["darwin", "x64", 0],
+  "aarch64-apple-ios": ["ios", "arm64", 0],
+  "x86_64-apple-ios": ["ios", "x64", 0],
+  "aarch64-linux-android": ["android", "arm64", 0],
+  "armv7-linux-androideabi": ["android", "arm", 0],
+  "i686-linux-android": ["android", "ia32", 0],
+  "x86_64-linux-android": ["android", "x64", 0],
+  "aarch64-pc-windows-msvc": ["win32", "arm64", 0],
+  "i686-pc-windows-gnu": ["win32", "ia32", 0],
+  "i686-pc-windows-msvc": ["win32", "ia32", 1],
+  "x86_64-pc-windows-gnu": ["win32", "x64", 0],
+  "x86_64-pc-windows-msvc": ["win32", "x64", 1],
+  "aarch64-unknown-linux-gnu": ["linux", "arm64", 0],
+  "aarch64-unknown-linux-musl": ["linux", "arm64", 1],
+  "arm-unknown-linux-gnueabihf": ["linux", "arm", 0],
+  "arm-unknown-linux-musleabihf": ["linux", "arm", 1],
+  "armv7-unknown-linux-gnueabihf": ["linux", "arm", 2],
+  "armv7-unknown-linux-musleabihf": ["linux", "arm", 3],
+  "i686-unknown-linux-gnu": ["linux", "ia32", 0],
+  "i686-unknown-linux-musl": ["linux", "ia32", 1],
+  "mips-unknown-linux-gnu": ["linux", "mips", 0],
+  "mips-unknown-linux-musl": ["linux", "mips", 1],
+  "mips64-unknown-linux-gnuabi64": ["linux", "mips64", 0],
+  "mips64-unknown-linux-muslabi64": ["linux", "mips64", 1],
+  "mips64el-unknown-linux-gnuabi64": ["linux", "mips64el", 0],
+  "mips64el-unknown-linux-muslabi64": ["linux", "mips64el", 1],
+  "mipsel-unknown-linux-gnu": ["linux", "mipsel", 0],
+  "mipsel-unknown-linux-musl": ["linux", "mipsel", 1],
+  "powerpc-unknown-linux-gnu": ["linux", "powerpc", 0],
+  "powerpc64-unknown-linux-gnu": ["linux", "powerpc64", 0],
+  "powerpc64le-unknown-linux-gnu": ["linux", "powerpc64le", 0],
+  "riscv64gc-unknown-linux-gnu": ["linux", "riscv64gc", 0],
+  "s390x-unknown-linux-gnu": ["linux", "s390x", 0],
+  "sparc64-unknown-linux-gnu": ["linux", "sparc64", 0],
+  "x86_64-unknown-linux-gnu": ["linux", "x64", 0],
+  "x86_64-unknown-linux-gnux32": ["linux", "x64", 1],
+  "x86_64-unknown-linux-musl": ["linux", "x64", 2],
+  "i686-unknown-freebsd": ["freebsd", "ia32", 0],
+  "x86_64-unknown-freebsd": ["freebsd", "x64", 0]
+}

package/data/node.json

@@ -0,0 +1,281 @@
+{
+  "darwin": {
+    "arm64": [{
+      "platform": "darwin",
+      "arch": "arm64",
+      "abi": null,
+      "node": "darwin-arm64",
+      "llvm": "aarch64-apple-darwin"
+    }],
+    "x64": [{
+      "platform": "darwin",
+      "arch": "x64",
+      "abi": null,
+      "node": "darwin-x64",
+      "llvm": "x86_64-apple-darwin"
+    }]
+  },
+  "ios": {
+    "arm64": [{
+      "platform": "ios",
+      "arch": "arm64",
+      "abi": null,
+      "node": "ios-arm64",
+      "llvm": "aarch64-apple-ios"
+    }],
+    "x64": [{
+      "platform": "ios",
+      "arch": "x64",
+      "abi": null,
+      "node": "ios-x64",
+      "llvm": "x86_64-apple-ios"
+    }]
+  },
+  "android": {
+    "arm64": [{
+      "platform": "android",
+      "arch": "arm64",
+      "abi": null,
+      "node": "android-arm64",
+      "llvm": "aarch64-linux-android"
+    }],
+    "arm": [{
+      "platform": "android",
+      "arch": "arm",
+      "abi": "eabi",
+      "node": "android-arm-eabi",
+      "llvm": "armv7-linux-androideabi"
+    }],
+    "ia32": [{
+      "platform": "android",
+      "arch": "ia32",
+      "abi": null,
+      "node": "android-ia32",
+      "llvm": "i686-linux-android"
+    }],
+    "x64": [{
+      "platform": "android",
+      "arch": "x64",
+      "abi": null,
+      "node": "android-x64",
+      "llvm": "x86_64-linux-android"
+    }]
+  },
+  "win32": {
+    "arm64": [{
+      "platform": "win32",
+      "arch": "arm64",
+      "abi": "msvc",
+      "node": "win32-arm64-msvc",
+      "llvm": "aarch64-pc-windows-msvc"
+    }],
+    "ia32": [{
+      "platform": "win32",
+      "arch": "ia32",
+      "abi": "gnu",
+      "node": "win32-ia32-gnu",
+      "llvm": "i686-pc-windows-gnu"
+    }, {
+      "platform": "win32",
+      "arch": "ia32",
+      "abi": "msvc",
+      "node": "win32-ia32-msvc",
+      "llvm": "i686-pc-windows-msvc"
+    }],
+    "x64": [{
+      "platform": "win32",
+      "arch": "x64",
+      "abi": "gnu",
+      "node": "win32-x64-gnu",
+      "llvm": "x86_64-pc-windows-gnu"
+    }, {
+      "platform": "win32",
+      "arch": "x64",
+      "abi": "msvc",
+      "node": "win32-x64-msvc",
+      "llvm": "x86_64-pc-windows-msvc"
+    }]
+  },
+  "linux": {
+    "arm64": [{
+      "platform": "linux",
+      "arch": "arm64",
+      "abi": "gnu",
+      "node": "linux-arm64-gnu",
+      "llvm": "aarch64-unknown-linux-gnu"
+    }, {
+      "platform": "linux",
+      "arch": "arm64",
+      "abi": "musl",
+      "node": "linux-arm64-musl",
+      "llvm": "aarch64-unknown-linux-musl"
+    }],
+    "arm": [{
+      "platform": "linux",
+      "arch": "arm",
+      "abi": "gnueabihf",
+      "node": "linux-arm-gnueabihf",
+      "llvm": "arm-unknown-linux-gnueabihf"
+    }, {
+      "platform": "linux",
+      "arch": "arm",
+      "abi": "musleabihf",
+      "node": "linux-arm-musleabihf",
+      "llvm": "arm-unknown-linux-musleabihf"
+    }, {
+      "platform": "linux",
+      "arch": "arm",
+      "abi": "gnueabihf",
+      "node": "linux-arm-gnueabihf",
+      "llvm": "armv7-unknown-linux-gnueabihf"
+    }, {
+      "platform": "linux",
+      "arch": "arm",
+      "abi": "musleabihf",
+      "node": "linux-arm-musleabihf",
+      "llvm": "armv7-unknown-linux-musleabihf"
+    }],
+    "ia32": [{
+      "platform": "linux",
+      "arch": "ia32",
+      "abi": "gnu",
+      "node": "linux-ia32-gnu",
+      "llvm": "i686-unknown-linux-gnu"
+    }, {
+      "platform": "linux",
+      "arch": "ia32",
+      "abi": "musl",
+      "node": "linux-ia32-musl",
+      "llvm": "i686-unknown-linux-musl"
+    }],
+    "mips": [{
+      "platform": "linux",
+      "arch": "mips",
+      "abi": "gnu",
+      "node": "linux-mips-gnu",
+      "llvm": "mips-unknown-linux-gnu"
+    }, {
+      "platform": "linux",
+      "arch": "mips",
+      "abi": "musl",
+      "node": "linux-mips-musl",
+      "llvm": "mips-unknown-linux-musl"
+    }],
+    "mips64": [{
+      "platform": "linux",
+      "arch": "mips64",
+      "abi": "gnuabi64",
+      "node": "linux-mips64-gnuabi64",
+      "llvm": "mips64-unknown-linux-gnuabi64"
+    }, {
+      "platform": "linux",
+      "arch": "mips64",
+      "abi": "muslabi64",
+      "node": "linux-mips64-muslabi64",
+      "llvm": "mips64-unknown-linux-muslabi64"
+    }],
+    "mips64el": [{
+      "platform": "linux",
+      "arch": "mips64el",
+      "abi": "gnuabi64",
+      "node": "linux-mips64el-gnuabi64",
+      "llvm": "mips64el-unknown-linux-gnuabi64"
+    }, {
+      "platform": "linux",
+      "arch": "mips64el",
+      "abi": "muslabi64",
+      "node": "linux-mips64el-muslabi64",
+      "llvm": "mips64el-unknown-linux-muslabi64"
+    }],
+    "mipsel": [{
+      "platform": "linux",
+      "arch": "mipsel",
+      "abi": "gnu",
+      "node": "linux-mipsel-gnu",
+      "llvm": "mipsel-unknown-linux-gnu"
+    }, {
+      "platform": "linux",
+      "arch": "mipsel",
+      "abi": "musl",
+      "node": "linux-mipsel-musl",
+      "llvm": "mipsel-unknown-linux-musl"
+    }],
+    "powerpc": [{
+      "platform": "linux",
+      "arch": "powerpc",
+      "abi": "gnu",
+      "node": "linux-powerpc-gnu",
+      "llvm": "powerpc-unknown-linux-gnu"
+    }],
+    "powerpc64": [{
+      "platform": "linux",
+      "arch": "powerpc64",
+      "abi": "gnu",
+      "node": "linux-powerpc64-gnu",
+      "llvm": "powerpc64-unknown-linux-gnu"
+    }],
+    "powerpc64le": [{
+      "platform": "linux",
+      "arch": "powerpc64le",
+      "abi": "gnu",
+      "node": "linux-powerpc64le-gnu",
+      "llvm": "powerpc64le-unknown-linux-gnu"
+    }],
+    "riscv64gc": [{
+      "platform": "linux",
+      "arch": "riscv64gc",
+      "abi": "gnu",
+      "node": "linux-riscv64gc-gnu",
+      "llvm": "riscv64gc-unknown-linux-gnu"
+    }],
+    "s390x": [{
+      "platform": "linux",
+      "arch": "s390x",
+      "abi": "gnu",
+      "node": "linux-s390x-gnu",
+      "llvm": "s390x-unknown-linux-gnu"
+    }],
+    "sparc64": [{
+      "platform": "linux",
+      "arch": "sparc64",
+      "abi": "gnu",
+      "node": "linux-sparc64-gnu",
+      "llvm": "sparc64-unknown-linux-gnu"
+    }],
+    "x64": [{
+      "platform": "linux",
+      "arch": "x64",
+      "abi": "gnu",
+      "node": "linux-x64-gnu",
+      "llvm": "x86_64-unknown-linux-gnu"
+    }, {
+      "platform": "linux",
+      "arch": "x64",
+      "abi": "gnux32",
+      "node": "linux-x64-gnux32",
+      "llvm": "x86_64-unknown-linux-gnux32"
+    }, {
+      "platform": "linux",
+      "arch": "x64",
+      "abi": "musl",
+      "node": "linux-x64-musl",
+      "llvm": "x86_64-unknown-linux-musl"
+    }]
+  },
+  "freebsd": {
+    "ia32": [{
+      "platform": "freebsd",
+      "arch": "ia32",
+      "abi": null,
+      "node": "freebsd-ia32",
+      "llvm": "i686-unknown-freebsd"
+    }],
+    "x64": [{
+      "platform": "freebsd",
+      "arch": "x64",
+      "abi": null,
+      "node": "freebsd-x64",
+      "llvm": "x86_64-unknown-freebsd"
+    }]
+  }
+}

package/dist/cargo.js

@@ -0,0 +1,159 @@
+import { createReadStream } from 'node:fs';
+import * as path from 'node:path';
+import * as readline from 'node:readline';
+import { execa } from 'execa';
+export function messageReason(message) {
+    return message.reason;
+}
+export function isCompilerMessage(json) {
+    if (!(json instanceof Object)) {
+        return false;
+    }
+    if (!('reason' in json) || (json.reason !== 'compiler-message')) {
+        return false;
+    }
+    return true;
+}
+export function isBuildScriptExecuted(json) {
+    if (!(json instanceof Object)) {
+        return false;
+    }
+    if (!('reason' in json) || (json.reason !== 'build-script-executed')) {
+        return false;
+    }
+    return true;
+}
+export function isCompilerTarget(json) {
+    if (!(json instanceof Object)) {
+        return false;
+    }
+    if (!('kind' in json) || !isStringArray(json.kind)) {
+        return false;
+    }
+    if (!('crate_types' in json) || !isStringArray(json.crate_types)) {
+        return false;
+    }
+    if (!('name' in json) || (typeof json.name !== 'string')) {
+        return false;
+    }
+    return true;
+}
+export function isCompilerArtifact(json) {
+    if (!(json instanceof Object)) {
+        return false;
+    }
+    if (!('reason' in json) || (json.reason !== 'compiler-artifact')) {
+        return false;
+    }
+    if (!('package_id' in json) || (typeof json.package_id !== 'string')) {
+        return false;
+    }
+    if (!('manifest_path' in json) || (typeof json.manifest_path !== 'string')) {
+        return false;
+    }
+    if (!('target' in json) || !isCompilerTarget(json.target)) {
+        return false;
+    }
+    if (!('filenames' in json) || !isStringArray(json.filenames)) {
+        return false;
+    }
+    return true;
+}
+function isStringArray(json) {
+    if (!Array.isArray(json)) {
+        return false;
+    }
+    for (const val of json) {
+        if (typeof val !== 'string') {
+            return false;
+        }
+    }
+    return true;
+}
+export function isBuildFinished(json) {
+    if (!(json instanceof Object)) {
+        return false;
+    }
+    if (!('reason' in json) || (json.reason !== 'build-finished')) {
+        return false;
+    }
+    return ('success' in json) && (typeof json.success === 'boolean');
+}
+export function parseMessage(line) {
+    try {
+        const json = JSON.parse(line);
+        if (isCompilerMessage(json) ||
+            isBuildScriptExecuted(json) ||
+            isCompilerArtifact(json) ||
+            isBuildFinished(json)) {
+            return json;
+        }
+    }
+    catch (nope) { }
+    return null;
+}
+export class MessageStream {
+    constructor(file) {
+        const input = file ? createReadStream(file) : process.stdin;
+        this._stream = readline.createInterface({
+            input,
+            terminal: false
+        });
+    }
+    async findPath(pred) {
+        try {
+            for await (const line of this._stream) {
+                const msg = parseMessage(line);
+                if (!msg) {
+                    continue;
+                }
+                const result = pred(msg);
+                if (result !== null) {
+                    return result;
+                }
+            }
+            return null;
+        }
+        finally {
+            this._stream.close();
+        }
+    }
+}
+export class CrossMessageStream extends MessageStream {
+    constructor(dir, file) {
+        super(file);
+        this._dir = dir;
+    }
+    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) {
+            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);
+        // 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,
+            shell: true
+        });
+        if (cargo.exitCode !== 0) {
+            throw new Error(`Invoking \`cargo metadata\` failed: ${cargo.stderr}`);
+        }
+        const cargoMetadata = JSON.parse(cargo.stdout);
+        // Finally, re-parent the relative path into an absolute path on the host system.
+        const absPath = path.join(cargoMetadata.target_directory, relPath);
+        return absPath;
+    }
+}

package/dist/commands/cross-dist.js

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,81 @@
+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/commands/dist.js

@@ -0,0 +1,38 @@
+import { copyFile } from 'node:fs/promises';
+import commandLineArgs from 'command-line-args';
+import { MessageStream, 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: '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;
+        }
+        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 file = options.file ?? await findArtifact(options.log, crateName);
+    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/index.js

@@ -0,0 +1,52 @@
+#!/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}`);
+    }
+}
+async function main() {
+    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);
+    }
+    catch (e) {
+        die((e instanceof Error) ? e.message : null);
+    }
+}
+main();

package/dist/usage.js

@@ -0,0 +1,150 @@
+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);
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@neon-rs/cli",
+  "version": "0.0.1",
+  "description": "Command-line build tool for Neon modules.",
+  "type": "module",
+  "exports": "./dist/index.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "data/**/*",
+    "dist/**/*",
+    "types/**/*",
+    "LICENSE*"
+  ],
+  "bin": {
+    "neon": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "pretest": "npm run build",
+    "prepack": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dherman/neon-rs.git"
+  },
+  "keywords": [
+    "Neon",
+    "Rust",
+    "Node"
+  ],
+  "author": "Dave Herman <david.herman@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/dherman/neon-rs/issues"
+  },
+  "homepage": "https://github.com/dherman/neon-rs#readme",
+  "devDependencies": {
+    "@tsconfig/node16": "^1.0.3",
+    "@types/command-line-args": "^5.2.0",
+    "@types/command-line-commands": "^2.0.1",
+    "@types/command-line-usage": "^5.0.2",
+    "@types/node": "^18.15.11",
+    "@types/temp": "^0.9.1",
+    "typescript": "^5.0.4"
+  },
+  "dependencies": {
+    "chalk": "^5.2.0",
+    "command-line-args": "^5.2.1",
+    "command-line-commands": "^3.0.2",
+    "command-line-usage": "^7.0.1",
+    "execa": "^7.1.1",
+    "stream-to-string": "^1.2.1",
+    "temp": "^0.9.4"
+  }
+}

package/types/cargo.d.ts

@@ -0,0 +1,42 @@
+export type MessageReason = 'compiler-artifact' | 'compiler-message' | 'build-script-executed' | 'build-finished';
+export type CompilerMessage = {
+    reason: 'compiler-message';
+};
+export type BuildScriptExecuted = {
+    reason: 'build-script-executed';
+};
+export type CompilerTarget = {
+    kind: string[];
+    crate_types: string[];
+    name: string;
+};
+export type CompilerArtifact = {
+    reason: 'compiler-artifact';
+    package_id: string;
+    manifest_path: string;
+    target: CompilerTarget;
+    filenames: string[];
+};
+export type BuildFinished = {
+    reason: 'build-finished';
+    success: boolean;
+};
+export type CargoMessage = CompilerMessage | BuildScriptExecuted | CompilerArtifact | BuildFinished;
+export declare function messageReason(message: CargoMessage): MessageReason;
+export declare function isCompilerMessage(json: unknown): json is CompilerMessage;
+export declare function isBuildScriptExecuted(json: unknown): json is BuildScriptExecuted;
+export declare function isCompilerTarget(json: unknown): json is CompilerTarget;
+export declare function isCompilerArtifact(json: unknown): json is CompilerArtifact;
+export declare function isBuildFinished(json: unknown): json is BuildFinished;
+export declare function parseMessage(line: string): CargoMessage | null;
+export type MessageFilter<T> = (msg: CargoMessage) => T | null;
+export declare class MessageStream {
+    private _stream;
+    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);
+    findPath(pred: MessageFilter<string>): Promise<string | null>;
+}

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

@@ -0,0 +1 @@
+export default function main(argv: string[]): Promise<void>;

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

@@ -0,0 +1 @@
+export default function main(argv: string[]): Promise<void>;

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

@@ -0,0 +1 @@
+export default function main(argv: string[]): Promise<void>;

package/types/commands/dist.d.ts

@@ -0,0 +1 @@
+export default function main(argv: string[]): Promise<void>;

package/types/index.d.ts

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

package/types/usage.d.ts

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