@airstrings/cli 0.13.5

package/bin/airstrings-mcp.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+'use strict';
+
+require('../lib/run.js').run('airstrings-mcp');

package/bin/airstrings.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+'use strict';
+
+require('../lib/run.js').run('airstrings');

package/install.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const { target, vendorDir, binaryPath } = require('./lib/binary.js');
+const { checksumFor } = require('./lib/checksums.js');
+const { version } = require('./package.json');
+
+const RELEASE_BASE = `https://github.com/symbionix-sl/homebrew-airstrings/releases/download/v${version}`;
+
+async function download(url) {
+  const res = await fetch(url, { redirect: 'follow' });
+  if (!res.ok) {
+    throw new Error(`airstrings: download failed with HTTP ${res.status} — ${url}`);
+  }
+  return Buffer.from(await res.arrayBuffer());
+}
+
+async function main() {
+  const { asset: platform, ext } = target();
+  const asset = `airstrings-v${version}-${platform}.${ext}`;
+
+  const [archive, sums] = await Promise.all([
+    download(`${RELEASE_BASE}/${asset}`),
+    download(`${RELEASE_BASE}/SHA256SUMS`),
+  ]);
+
+  const expected = checksumFor(sums, asset);
+  const actual = crypto.createHash('sha256').update(archive).digest('hex');
+  if (actual !== expected) {
+    throw new Error(
+      `airstrings: checksum mismatch for ${asset}\n  expected ${expected}\n  actual   ${actual}\n` +
+        `Refusing to install a binary that does not match the published checksum.`
+    );
+  }
+
+  const tmp = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'airstrings-')), asset);
+  fs.writeFileSync(tmp, archive);
+
+  fs.rmSync(vendorDir, { recursive: true, force: true });
+  fs.mkdirSync(vendorDir, { recursive: true });
+  execFileSync('tar', ['-xf', tmp, '-C', vendorDir]);
+  fs.rmSync(path.dirname(tmp), { recursive: true, force: true });
+
+  if (process.platform !== 'win32') {
+    for (const name of ['airstrings', 'airstrings-mcp']) {
+      fs.chmodSync(binaryPath(name), 0o755);
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/lib/binary.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const path = require('path');
+
+const TARGETS = {
+  'darwin-arm64': { asset: 'darwin-arm64', ext: 'tar.gz' },
+  'darwin-x64': { asset: 'darwin-amd64', ext: 'tar.gz' },
+  'linux-arm64': { asset: 'linux-arm64', ext: 'tar.gz' },
+  'linux-x64': { asset: 'linux-amd64', ext: 'tar.gz' },
+  'win32-x64': { asset: 'windows-amd64', ext: 'zip' },
+};
+
+const vendorDir = path.join(__dirname, '..', 'vendor');
+
+function target() {
+  const key = `${process.platform}-${process.arch}`;
+  const found = TARGETS[key];
+  if (!found) {
+    throw new Error(
+      `airstrings: no prebuilt binary for ${key}. Supported: ${Object.keys(TARGETS).join(', ')}. ` +
+        `Install with Homebrew instead: brew install symbionix-sl/airstrings/airstrings`
+    );
+  }
+  return found;
+}
+
+function binaryPath(name) {
+  const ext = process.platform === 'win32' ? '.exe' : '';
+  return path.join(vendorDir, `${name}${ext}`);
+}
+
+module.exports = { target, vendorDir, binaryPath };

package/lib/checksums.js

@@ -0,0 +1,14 @@
+'use strict';
+
+function checksumFor(sums, asset) {
+  const line = String(sums)
+    .split('\n')
+    .map((l) => l.trim().split(/\s+/))
+    .find(([, name]) => name === asset);
+  if (!line) {
+    throw new Error(`airstrings: no checksum published for ${asset}`);
+  }
+  return line[0];
+}
+
+module.exports = { checksumFor };

package/lib/run.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+
+const { binaryPath } = require('./binary.js');
+
+function run(name) {
+  const bin = binaryPath(name);
+  if (!fs.existsSync(bin)) {
+    console.error(`airstrings: ${name} binary is missing — reinstall the package to fetch it.`);
+    process.exit(1);
+  }
+
+  const result = spawnSync(bin, process.argv.slice(2), { stdio: 'inherit' });
+
+  if (result.error) {
+    console.error(`airstrings: failed to run ${name} — ${result.error.message}`);
+    process.exit(1);
+  }
+  if (result.signal) {
+    process.kill(process.pid, result.signal);
+    return;
+  }
+  process.exit(result.status ?? 1);
+}
+
+module.exports = { run };

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@airstrings/cli",
+  "version": "0.13.5",
+  "description": "CLI for the AirStrings remote string management platform",
+  "homepage": "https://airstrings.com",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/symbionix-sl/airstrings-cli.git",
+    "directory": "npm"
+  },
+  "keywords": [
+    "airstrings",
+    "cli",
+    "localization",
+    "i18n",
+    "strings"
+  ],
+  "bin": {
+    "airstrings": "bin/airstrings.js",
+    "airstrings-mcp": "bin/airstrings-mcp.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "install.js"
+  ],
+  "scripts": {
+    "postinstall": "node install.js",
+    "test": "node test.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}