nanoai-cli 1.0.7

package/README.md

@@ -0,0 +1,54 @@
+# nanoagent
+
+The NanoAgent CLI (`nanoai`) — terminal UI, ACP server, and automation-friendly agent.
+
+This package is a thin installer: on install (or on first run) it downloads the
+matching self-contained NanoAgent CLI binary from the project's
+[GitHub Releases](https://github.com/rizwan3d/NanoAgent/releases) and verifies it
+against the published `SHA256SUMS`. No build toolchain is required.
+
+## Install
+
+```bash
+npm install -g nanoagent
+# or
+bun add -g nanoagent
+# or
+pnpm add -g nanoagent
+```
+
+Then run:
+
+```bash
+nanoai
+```
+
+> **bun note:** bun skips `postinstall` scripts by default, so the binary is
+> downloaded automatically the first time you run `nanoai`. To download eagerly,
+> run `bunx nanoagent --version` once after installing.
+
+## Supported platforms
+
+| OS      | Architecture |
+| ------- | ------------ |
+| Windows | x64          |
+| macOS   | x64, arm64   |
+| Linux   | x64, arm64   |
+
+## Environment variables
+
+| Variable                  | Purpose                                                        |
+| ------------------------- | -------------------------------------------------------------- |
+| `NANOAGENT_SKIP_DOWNLOAD` | Set to `1` to skip the postinstall download (fetched on run).  |
+| `NANOAGENT_CLI_TAG`       | Override the release tag to download (default `v<version>`).   |
+| `NANOAGENT_CLI_BASE_URL`  | Override the release asset base URL (mirrors, testing).        |
+
+## Reinstalling the binary
+
+```bash
+node node_modules/nanoagent/scripts/download.js
+```
+
+## License
+
+Apache-2.0

package/bin/nanoai.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+"use strict";
+
+// Launcher for the NanoAgent CLI. Spawns the vendored native binary, passing
+// through all arguments, stdio, and the exit code. If the binary is missing
+// (e.g. postinstall was skipped by bun, or a prior download failed), it is
+// downloaded on demand before the first launch.
+
+const fs = require("fs");
+const { spawn } = require("child_process");
+
+const platform = require("../scripts/platform");
+
+function launch(binaryPath) {
+  const child = spawn(binaryPath, process.argv.slice(2), { stdio: "inherit" });
+
+  child.on("error", (err) => {
+    console.error(`[nanoagent] Failed to start NanoAgent CLI: ${err.message}`);
+    process.exit(1);
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      // Re-raise the terminating signal so shells see the real cause.
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code === null ? 1 : code);
+  });
+
+  // Forward termination signals to the child so Ctrl+C behaves normally.
+  for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(sig, () => {
+      if (!child.killed) {
+        try {
+          child.kill(sig);
+        } catch {
+          /* child already gone */
+        }
+      }
+    });
+  }
+}
+
+async function main() {
+  const binaryPath = platform.installedBinaryPath();
+
+  if (!fs.existsSync(binaryPath)) {
+    const { ensureBinary } = require("../scripts/download");
+    try {
+      await ensureBinary({ log: (m) => console.error(`[nanoagent] ${m}`) });
+    } catch (err) {
+      console.error(`[nanoagent] Unable to download the NanoAgent CLI binary: ${err.message}`);
+      console.error("[nanoagent] Check your network connection and try running `nanoai` again.");
+      process.exit(1);
+    }
+  }
+
+  launch(binaryPath);
+}
+
+main();

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "nanoai-cli",
+  "version": "1.0.7",
+  "description": "Terminal UI, ACP server, and automation-friendly CLI for NanoAgent.",
+  "keywords": [
+    "nanoagent",
+    "nanoai",
+    "ai",
+    "agent",
+    "cli",
+    "acp",
+    "coding-agent"
+  ],
+  "homepage": "https://github.com/rizwan3d/NanoAgent#readme",
+  "bugs": {
+    "url": "https://github.com/rizwan3d/NanoAgent/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rizwan3d/NanoAgent.git",
+    "directory": "packaging/npm"
+  },
+  "license": "Apache-2.0",
+  "author": "NanoAgent",
+  "type": "commonjs",
+  "bin": {
+    "nanoai": "bin/nanoai.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "win32",
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "dependencies": {
+    "adm-zip": "^0.5.16"
+  }
+}

package/scripts/download.js

@@ -0,0 +1,132 @@
+"use strict";
+
+// Downloads, verifies, and extracts the NanoAgent CLI binary from the matching
+// GitHub release. Shared by the postinstall step and the runtime launcher so the
+// CLI self-heals on first run even when a package manager skips lifecycle
+// scripts (notably `bun install`, which does not run postinstall by default).
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const AdmZip = require("adm-zip");
+
+const platform = require("./platform");
+
+async function fetchBuffer(url) {
+  if (typeof fetch !== "function") {
+    throw new Error(
+      "Global fetch is unavailable. NanoAgent's npm package requires Node.js 18 or newer."
+    );
+  }
+
+  const response = await fetch(url, {
+    redirect: "follow",
+    headers: { "User-Agent": `${platform.APP_NAME}-npm-installer` },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Request to ${url} failed with HTTP ${response.status} ${response.statusText}.`);
+  }
+
+  return Buffer.from(await response.arrayBuffer());
+}
+
+function parseExpectedChecksum(checksumsText, assetName) {
+  for (const rawLine of checksumsText.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    const match = line.match(/^([0-9a-fA-F]{64})[\s*]+(.+)$/);
+    if (!match) continue;
+
+    let file = match[2].trim();
+    file = file.replace(/^\*/, "").replace(/^\.\//, "");
+
+    if (file === assetName) {
+      return match[1].toLowerCase();
+    }
+  }
+  return null;
+}
+
+function sha256(buffer) {
+  return crypto.createHash("sha256").update(buffer).digest("hex").toLowerCase();
+}
+
+function extractExecutable(zipBuffer, destinationPath) {
+  const zip = new AdmZip(zipBuffer);
+  const wanted = platform.executableFileName();
+
+  const entry = zip.getEntries().find((candidate) => {
+    if (candidate.isDirectory) return false;
+    const base = candidate.entryName.split("/").pop();
+    return base === wanted;
+  });
+
+  if (!entry) {
+    throw new Error(`Release archive did not contain the expected executable '${wanted}'.`);
+  }
+
+  const data = entry.getData();
+  fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+  fs.writeFileSync(destinationPath, data);
+  if (process.platform !== "win32") {
+    fs.chmodSync(destinationPath, 0o755);
+  }
+}
+
+// Ensures the platform binary is present in vendor/. Returns the absolute path.
+async function ensureBinary(options = {}) {
+  const { force = false, log = () => {} } = options;
+
+  const binaryPath = platform.installedBinaryPath();
+  if (!force && fs.existsSync(binaryPath)) {
+    return binaryPath;
+  }
+
+  const rid = platform.resolveRid();
+  const asset = platform.assetName(rid);
+  const base = platform.baseDownloadUrl();
+  const assetUrl = `${base}/${asset}`;
+  const checksumsUrl = `${base}/${platform.CHECKSUMS_NAME}`;
+
+  log(`Downloading ${asset} (${platform.resolveTag()})...`);
+  const archiveBuffer = await fetchBuffer(assetUrl);
+
+  log(`Verifying ${platform.CHECKSUMS_NAME}...`);
+  const checksumsText = (await fetchBuffer(checksumsUrl)).toString("utf8");
+  const expected = parseExpectedChecksum(checksumsText, asset);
+  if (!expected) {
+    throw new Error(`${platform.CHECKSUMS_NAME} does not contain a checksum for ${asset}.`);
+  }
+
+  const actual = sha256(archiveBuffer);
+  if (actual !== expected) {
+    throw new Error(
+      `SHA256 verification failed for ${asset}. Expected ${expected}, got ${actual}.`
+    );
+  }
+
+  log("Extracting NanoAgent CLI...");
+  // Extract to a temp file first, then rename so concurrent runs never observe
+  // a partially written executable.
+  const tempPath = path.join(
+    platform.vendorDir(),
+    `.${platform.executableFileName()}.${process.pid}.tmp`
+  );
+  extractExecutable(archiveBuffer, tempPath);
+  fs.renameSync(tempPath, binaryPath);
+
+  log(`Installed NanoAgent CLI to ${binaryPath}.`);
+  return binaryPath;
+}
+
+module.exports = { ensureBinary, parseExpectedChecksum };
+
+// Allow `node scripts/download.js` for manual/forced reinstall.
+if (require.main === module) {
+  ensureBinary({ force: true, log: (m) => console.error(`[nanoagent] ${m}`) }).catch((err) => {
+    console.error(`[nanoagent] ${err.message}`);
+    process.exit(1);
+  });
+}

package/scripts/platform.js

@@ -0,0 +1,100 @@
+"use strict";
+
+// Shared platform/asset resolution used by both the postinstall step and the
+// runtime launcher. Keep this dependency-free so it loads in any environment.
+
+const os = require("os");
+const path = require("path");
+
+const OWNER = "rizwan3d";
+const REPO = "NanoAgent";
+const APP_NAME = "NanoAgent.CLI";
+// Executable name inside the release archive (matches the AOT-published output).
+const EXECUTABLE_NAME = "NanoAgent.CLI";
+const CHECKSUMS_NAME = "SHA256SUMS";
+
+// Maps Node's process.platform/process.arch onto the .NET runtime identifiers
+// used for the published release assets.
+function resolveRid() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform === "win32") {
+    if (arch === "x64") return "win-x64";
+    throw new Error(`Unsupported Windows architecture '${arch}'. NanoAgent ships win-x64 only.`);
+  }
+
+  if (platform === "darwin") {
+    if (arch === "x64") return "osx-x64";
+    if (arch === "arm64") return "osx-arm64";
+    throw new Error(`Unsupported macOS architecture '${arch}'.`);
+  }
+
+  if (platform === "linux") {
+    if (arch === "x64") return "linux-x64";
+    if (arch === "arm64") return "linux-arm64";
+    throw new Error(`Unsupported Linux architecture '${arch}'.`);
+  }
+
+  throw new Error(`Unsupported operating system '${platform}'.`);
+}
+
+function executableFileName() {
+  return process.platform === "win32" ? `${EXECUTABLE_NAME}.exe` : EXECUTABLE_NAME;
+}
+
+// Version baked into package.json by the release workflow; the matching release
+// is tagged "v<version>".
+function resolveVersion() {
+  const override = process.env.NANOAGENT_CLI_VERSION;
+  if (override && override.trim()) {
+    return override.trim().replace(/^v/i, "");
+  }
+  const pkg = require(path.join(__dirname, "..", "package.json"));
+  return pkg.version;
+}
+
+function resolveTag() {
+  const override = process.env.NANOAGENT_CLI_TAG;
+  if (override && override.trim()) {
+    return override.trim();
+  }
+  return `v${resolveVersion()}`;
+}
+
+function baseDownloadUrl() {
+  const override = process.env.NANOAGENT_CLI_BASE_URL;
+  if (override && override.trim()) {
+    return override.trim().replace(/\/+$/, "");
+  }
+  return `https://github.com/${OWNER}/${REPO}/releases/download/${resolveTag()}`;
+}
+
+function assetName(rid) {
+  return `${APP_NAME}-${rid}.zip`;
+}
+
+function vendorDir() {
+  return path.join(__dirname, "..", "vendor");
+}
+
+function installedBinaryPath() {
+  return path.join(vendorDir(), executableFileName());
+}
+
+module.exports = {
+  OWNER,
+  REPO,
+  APP_NAME,
+  EXECUTABLE_NAME,
+  CHECKSUMS_NAME,
+  resolveRid,
+  executableFileName,
+  resolveVersion,
+  resolveTag,
+  baseDownloadUrl,
+  assetName,
+  vendorDir,
+  installedBinaryPath,
+  homedir: os.homedir,
+};

package/scripts/postinstall.js

@@ -0,0 +1,24 @@
+"use strict";
+
+// Runs after `npm install`/`pnpm install`. Best-effort: if the download fails
+// (offline, proxy, rate limit) we do NOT fail the install. The binary is fetched
+// lazily on first `nanoai` invocation instead. This also keeps `bun install`
+// working, since bun skips postinstall scripts by default.
+
+// Skip in CI/build contexts that set npm_config_global=false dev installs of the
+// monorepo, or when the user explicitly opts out.
+if (process.env.NANOAGENT_SKIP_DOWNLOAD === "1") {
+  process.exit(0);
+}
+
+const { ensureBinary } = require("./download");
+
+ensureBinary({ log: (m) => console.error(`[nanoagent] ${m}`) })
+  .then(() => {
+    console.error("[nanoagent] Ready. Run `nanoai` to start.");
+  })
+  .catch((err) => {
+    console.error(`[nanoagent] Could not pre-download the CLI binary: ${err.message}`);
+    console.error("[nanoagent] It will be downloaded automatically the first time you run `nanoai`.");
+    // Intentionally exit 0 so install succeeds.
+  });