@fatalmistake02/rian 0.0.0-stage → 0.2.1

package/scripts/check-package.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawnSync } = require('node:child_process');
+const { targets, targetFor } = require('../lib/platforms.cjs');
+const { binaryPath } = require('../lib/launcher.cjs');
+
+const root = path.resolve(__dirname, '..');
+const pkg = require('../package.json');
+
+function checkPackage(packageRoot = root) {
+  const assetRoot = path.join(packageRoot, 'dist', 'binaries');
+  const manifest = JSON.parse(fs.readFileSync(path.join(assetRoot, 'manifest.json'), 'utf8'));
+  if (manifest.version !== pkg.version) throw new Error('Binary version is stale; run npm run build');
+  if (Object.keys(manifest.targets).length !== targets.length) throw new Error('The binary manifest must contain all six platforms');
+  for (const item of targets) {
+    const target = targetFor(item.platform, item.arch);
+    const expected = `${target.key}/${target.filename}`;
+    const info = manifest.targets[target.key];
+    if (!info || info.file !== expected) throw new Error(`Missing ${target.key} executable`);
+    const data = fs.readFileSync(path.join(assetRoot, expected));
+    if (data.length < 1024) throw new Error(`${target.key} is not a built executable`);
+    const actual = crypto.createHash('sha256').update(data).digest('hex');
+    if (actual !== info.sha256) throw new Error(`${target.key} checksum does not match`);
+    if (target.platform === 'darwin') {
+      if (data.readUInt32LE(0) !== 0xfeedfacf || data.readUInt32LE(4) !== (target.arch === 'arm64' ? 0x100000c : 0x1000007)) throw new Error(`Wrong Mach-O architecture for ${target.key}`);
+    } else if (target.platform === 'linux') {
+      if (data.subarray(0, 4).toString('hex') !== '7f454c46' || data[4] !== 2 || data.readUInt16LE(18) !== (target.arch === 'arm64' ? 183 : 62)) throw new Error(`Wrong ELF architecture for ${target.key}`);
+    } else {
+      const header = data.readUInt32LE(0x3c);
+      if (data.subarray(0, 2).toString() !== 'MZ' || data.readUInt32LE(header) !== 0x4550 || data.readUInt16LE(header + 4) !== (target.arch === 'arm64' ? 0xaa64 : 0x8664)) throw new Error(`Wrong PE architecture for ${target.key}`);
+    }
+  }
+  for (const file of ['LICENSE', 'THIRD_PARTY_NOTICES.txt', 'bin/rian.cjs', 'scripts/ensure-binary.cjs']) {
+    if (!fs.statSync(path.join(packageRoot, file)).isFile()) throw new Error(`Missing ${file}`);
+  }
+  const result = spawnSync(binaryPath(packageRoot), ['--version'], { encoding: 'utf8', windowsHide: true });
+  if (result.error || result.status !== 0 || result.stdout.trim() !== `rian ${pkg.version}`) throw new Error('The current-platform executable failed the version check');
+  return manifest;
+}
+
+if (require.main === module) {
+  try { checkPackage(); console.log(`Rian ${pkg.version}: all six binaries, checksums, architectures, and package files verified.`); }
+  catch (err) { console.error(`rian package: ${err.message}`); process.exitCode = 1; }
+}
+
+module.exports = { checkPackage };

package/scripts/ensure-binary.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+// This only fixes executable permissions. No downloads or builds happen on
+// the user's machine. The launcher also repairs permissions if scripts are off.
+const path = require('node:path');
+const { binaryPath } = require('../lib/launcher.cjs');
+
+try { binaryPath(path.resolve(__dirname, '..')); } catch (err) {
+  console.error(`rian: ${err.message}`);
+  process.exitCode = 1;
+}

package/test/npm/launcher.test.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { EventEmitter } = require('node:events');
+const { targets, targetFor } = require('../../lib/platforms.cjs');
+const { binaryPath, launch } = require('../../lib/launcher.cjs');
+
+test('dispatches all six platform/architecture combinations', t => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'rian-launcher-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  for (const item of targets) {
+    const target = targetFor(item.platform, item.arch);
+    const file = path.join(root, 'dist', 'binaries', target.key, target.filename);
+    fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, 'fixture');
+    assert.equal(binaryPath(root, item.platform, item.arch), file);
+  }
+  assert.throws(() => binaryPath(root, 'freebsd', 'x64'), /does not support/);
+  assert.throws(() => binaryPath(root, 'darwin', 'ia32'), /does not support/);
+});
+
+test('missing binaries give an actionable install error', () => {
+  assert.throws(() => binaryPath(path.join(os.tmpdir(), 'rian-missing-install')), /npm install -g @fatalmistake02\/rian/);
+});
+
+test('preserves arguments, terminal stdio, working directory, and child exit status', () => {
+  const root = path.resolve(__dirname, '../..');
+  const child = new EventEmitter(); child.exitCode = null; child.signalCode = null;
+  const oldCode = process.exitCode;
+  const oldHandlerCount = process.listenerCount('SIGTERM');
+  let invocation;
+  const args = ['add', '/directory with spaces', '--yes'];
+  launch(root, args, (file, passed, options) => { invocation = { file, passed, options }; return child; });
+  assert.deepEqual(invocation.passed, args);
+  assert.equal(invocation.options.stdio, 'inherit');
+  assert.equal(invocation.options.shell, false);
+  assert.equal(invocation.options.cwd, undefined);
+  child.emit('exit', 7, null);
+  assert.equal(process.exitCode, 7);
+  assert.equal(process.listenerCount('SIGTERM'), oldHandlerCount);
+  process.exitCode = oldCode;
+});

package/test/npm/package.test.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { checkPackage } = require('../../scripts/check-package.cjs');
+const pkg = require('../../package.json');
+
+test('built package includes verified native executables for every supported platform', () => {
+  const manifest = checkPackage();
+  assert.equal(manifest.version, pkg.version);
+  assert.equal(Object.keys(manifest.targets).length, 6);
+  assert.equal(pkg.bin.rian, 'bin/rian.cjs');
+});
+
+test('npm launcher runs the native executable and returns errors cleanly', () => {
+  const root = path.resolve(__dirname, '../..');
+  const launcher = path.join(root, 'bin', 'rian.cjs');
+  const version = spawnSync(process.execPath, [launcher, '--version'], { encoding: 'utf8', cwd: path.dirname(root), windowsHide: true });
+  assert.equal(version.status, 0, version.stderr);
+  assert.equal(version.stdout.trim(), `rian ${pkg.version}`);
+  const invalid = spawnSync(process.execPath, [launcher, 'invalid-subcommand'], { encoding: 'utf8', windowsHide: true });
+  assert.equal(invalid.status, 1);
+  assert.match(invalid.stderr, /unknown command/);
+});