nanoai-cli 1.0.7 → 1.0.9

package/README.md

@@ -1,54 +1,113 @@
-# nanoagent
+# nanoai-cli
 
-The NanoAgent CLI (`nanoai`) — terminal UI, ACP server, and automation-friendly agent.
+`nanoai-cli` installs the NanoAgent CLI as the `nanoai` command.
 
-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.
+NanoAgent is a local AI coding agent for terminal workflows, ACP-compatible editors, and automation. This npm package is a thin installer: it downloads the matching self-contained NanoAgent release for your platform, verifies it against the published `SHA256SUMS`, and launches it without requiring a .NET toolchain.
+
+## Why use this package
+
+- Install NanoAgent with `npm`, `pnpm`, or `bun`.
+- Download the correct native binary for the current platform automatically.
+- Verify release archives before extraction with published SHA-256 checksums.
+- Recover automatically on first run if `postinstall` was skipped or the binary is missing.
 
 ## Install
 
 ```bash
-npm install -g nanoagent
+npm install -g nanoai-cli
 # or
-bun add -g nanoagent
+pnpm add -g nanoai-cli
 # or
-pnpm add -g nanoagent
+bun add -g nanoai-cli
 ```
 
-Then run:
+Start NanoAgent:
 
 ```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.
+If you want a quick non-interactive smoke test after install:
+
+```bash
+nanoai --version
+```
+
+## How installation works
+
+On install, the package tries to:
+
+1. Resolve the correct release asset for the current OS and CPU architecture.
+2. Download the matching `NanoAgent.CLI-<rid>.zip` archive from GitHub Releases.
+3. Download `SHA256SUMS` from the same release.
+4. Verify the archive checksum before extraction.
+5. Extract the NanoAgent binary into the package's `vendor/` directory.
+
+If the download is skipped or fails during `postinstall`, installation still succeeds. The launcher downloads the binary automatically the first time you run `nanoai`.
+
+## bun note
+
+`bun add` skips `postinstall` scripts by default, so the binary is usually downloaded on first launch instead of during installation.
+
+To fetch it eagerly after installing with bun, run:
+
+```bash
+bunx nanoai-cli --version
+```
 
 ## Supported platforms
 
-| OS      | Architecture |
-| ------- | ------------ |
-| Windows | x64          |
-| macOS   | x64, arm64   |
-| Linux   | x64, arm64   |
+| OS | Architectures |
+| --- | --- |
+| Windows | x64 |
+| macOS | x64, arm64 |
+| Linux | x64, arm64 |
+
+## Updates
+
+By default, the package downloads the release tag that matches the npm package version, using `v<package-version>`.
+
+At runtime, the launcher can also check GitHub for a newer NanoAgent release. When running interactively, it prompts before replacing the installed binary with the latest release and then continues launch.
+
+Skip the runtime update prompt with either:
+
+```bash
+nanoai --no-update-check
+```
+
+or:
+
+```bash
+NANOAGENT_SKIP_UPDATE_CHECK=1 nanoai
+```
 
 ## 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).        |
+| Variable | Purpose |
+| --- | --- |
+| `NANOAGENT_SKIP_DOWNLOAD` | Set to `1` to skip the install-time download. The binary will still be fetched on first run. |
+| `NANOAGENT_SKIP_UPDATE_CHECK` | Set to `1` to disable the runtime check for newer GitHub releases. |
+| `NANOAGENT_CLI_TAG` | Override the release tag to download, such as `v1.2.3`. |
+| `NANOAGENT_CLI_VERSION` | Override the version used to derive the default release tag. |
+| `NANOAGENT_CLI_BASE_URL` | Override the release asset base URL for mirrors, testing, or private distribution. |
+
+## Manual reinstall
 
-## Reinstalling the binary
+If you need to force a fresh binary download for a local install, run:
 
 ```bash
-node node_modules/nanoagent/scripts/download.js
+node ./node_modules/nanoai-cli/scripts/download.js
 ```
 
+If the package was installed globally, reinstalling the package is usually the simplest way to refresh the bundled launcher files.
+
+## Learn more
+
+- Product overview: [NanoAgent README](https://github.com/rizwan3d/NanoAgent#readme)
+- Full documentation: [docs/documentation.md](https://github.com/rizwan3d/NanoAgent/blob/master/docs/documentation.md)
+- Releases: [GitHub Releases](https://github.com/rizwan3d/NanoAgent/releases)
+- Issues: [GitHub Issues](https://github.com/rizwan3d/NanoAgent/issues)
+
 ## License
 
 Apache-2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nanoai-cli",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Terminal UI, ACP server, and automation-friendly CLI for NanoAgent.",
   "keywords": [
     "nanoagent",
@@ -47,6 +47,7 @@
     "arm64"
   ],
   "dependencies": {
+    "@inquirer/select": "^4.4.0",
     "adm-zip": "^0.5.16"
   }
 }

package/scripts/download.js

@@ -77,7 +77,7 @@ function extractExecutable(zipBuffer, destinationPath) {
 
 // Ensures the platform binary is present in vendor/. Returns the absolute path.
 async function ensureBinary(options = {}) {
-  const { force = false, log = () => {} } = options;
+  const { force = false, log = () => {}, tag } = options;
 
   const binaryPath = platform.installedBinaryPath();
   if (!force && fs.existsSync(binaryPath)) {
@@ -86,11 +86,14 @@ async function ensureBinary(options = {}) {
 
   const rid = platform.resolveRid();
   const asset = platform.assetName(rid);
-  const base = platform.baseDownloadUrl();
+  const resolvedTag = tag && tag.trim()
+    ? tag.trim()
+    : platform.resolveTag();
+  const base = platform.baseDownloadUrl(resolvedTag);
   const assetUrl = `${base}/${asset}`;
   const checksumsUrl = `${base}/${platform.CHECKSUMS_NAME}`;
 
-  log(`Downloading ${asset} (${platform.resolveTag()})...`);
+  log(`Downloading ${asset} (${resolvedTag})...`);
   const archiveBuffer = await fetchBuffer(assetUrl);
 
   log(`Verifying ${platform.CHECKSUMS_NAME}...`);

package/scripts/platform.js

@@ -62,12 +62,15 @@ function resolveTag() {
   return `v${resolveVersion()}`;
 }
 
-function baseDownloadUrl() {
+function baseDownloadUrl(tagOverride) {
   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()}`;
+  const tag = tagOverride && tagOverride.trim()
+    ? tagOverride.trim()
+    : resolveTag();
+  return `https://github.com/${OWNER}/${REPO}/releases/download/${tag}`;
 }
 
 function assetName(rid) {

package/scripts/update.js

@@ -0,0 +1,244 @@
+"use strict";
+
+const fs = require("fs");
+const { spawnSync } = require("child_process");
+
+const platform = require("./platform");
+const { ensureBinary } = require("./download");
+
+const LatestReleaseApiUrl = `https://api.github.com/repos/${platform.OWNER}/${platform.REPO}/releases/latest`;
+const VersionPattern = /\b(?:NanoAgent\s+CLI\s+)?v?(\d+(?:\.\d+){1,3}(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)\b/i;
+
+function normalizeVersionText(value) {
+  if (!value || !value.trim()) {
+    return "0.0.0";
+  }
+
+  let normalized = value.trim();
+  const metadataIndex = normalized.indexOf("+");
+  if (metadataIndex >= 0) {
+    normalized = normalized.slice(0, metadataIndex);
+  }
+
+  if (normalized.startsWith("v") || normalized.startsWith("V")) {
+    normalized = normalized.slice(1);
+  }
+
+  return normalized;
+}
+
+function parseComparableVersion(value) {
+  const normalized = normalizeVersionText(value);
+  const prereleaseIndex = normalized.indexOf("-");
+  const releasePart = prereleaseIndex >= 0
+    ? normalized.slice(0, prereleaseIndex)
+    : normalized;
+  const segments = releasePart
+    .split(".")
+    .map((segment) => Number.parseInt(segment, 10));
+
+  if (segments.length === 0 || segments.some((segment) => !Number.isFinite(segment))) {
+    return null;
+  }
+
+  while (segments.length < 4) {
+    segments.push(0);
+  }
+
+  return {
+    normalized,
+    segments,
+    hasPrerelease: prereleaseIndex >= 0,
+  };
+}
+
+function compareVersions(left, right) {
+  const parsedLeft = parseComparableVersion(left);
+  const parsedRight = parseComparableVersion(right);
+
+  if (!parsedLeft || !parsedRight) {
+    const normalizedLeft = normalizeVersionText(left);
+    const normalizedRight = normalizeVersionText(right);
+    return normalizedLeft.localeCompare(normalizedRight, undefined, { numeric: true, sensitivity: "base" });
+  }
+
+  for (let index = 0; index < Math.max(parsedLeft.segments.length, parsedRight.segments.length); index += 1) {
+    const leftSegment = parsedLeft.segments[index] ?? 0;
+    const rightSegment = parsedRight.segments[index] ?? 0;
+    if (leftSegment !== rightSegment) {
+      return leftSegment - rightSegment;
+    }
+  }
+
+  if (parsedLeft.hasPrerelease !== parsedRight.hasPrerelease) {
+    return parsedLeft.hasPrerelease ? -1 : 1;
+  }
+
+  return parsedLeft.normalized.localeCompare(
+    parsedRight.normalized,
+    undefined,
+    { numeric: true, sensitivity: "base" }
+  );
+}
+
+async function fetchLatestRelease(options = {}) {
+  const { timeoutMs = 4000 } = options;
+  if (typeof fetch !== "function") {
+    return null;
+  }
+
+  const response = await fetch(LatestReleaseApiUrl, {
+    headers: {
+      "Accept": "application/vnd.github+json",
+      "User-Agent": `${platform.APP_NAME}-npm-launcher`,
+    },
+    redirect: "follow",
+    signal: typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function"
+      ? AbortSignal.timeout(timeoutMs)
+      : undefined,
+  });
+
+  if (!response.ok) {
+    throw new Error(`GitHub returned HTTP ${response.status} ${response.statusText}.`);
+  }
+
+  const payload = await response.json();
+  const tag = typeof payload?.tag_name === "string" ? payload.tag_name.trim() : "";
+  if (!tag) {
+    throw new Error("GitHub did not return a release tag.");
+  }
+
+  const releaseUrl = typeof payload?.html_url === "string" && payload.html_url.trim()
+    ? payload.html_url.trim()
+    : `https://github.com/${platform.OWNER}/${platform.REPO}/releases/latest`;
+
+  return {
+    tag,
+    version: normalizeVersionText(tag),
+    releaseUrl,
+  };
+}
+
+function readInstalledBinaryVersion(binaryPath) {
+  if (!binaryPath || !fs.existsSync(binaryPath)) {
+    return null;
+  }
+
+  try {
+    const result = spawnSync(binaryPath, ["--version"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 10000,
+      windowsHide: true,
+    });
+
+    const combined = `${result.stdout || ""}\n${result.stderr || ""}`;
+    const match = combined.match(VersionPattern);
+    return match?.[1] ? normalizeVersionText(match[1]) : null;
+  } catch {
+    return null;
+  }
+}
+
+function shouldSkipRuntimeUpdateCheck() {
+  if (process.env.NANOAGENT_SKIP_UPDATE_CHECK === "1") {
+    return true;
+  }
+
+  if (process.env.NANOAGENT_CLI_TAG || process.env.NANOAGENT_CLI_BASE_URL || process.env.NANOAGENT_CLI_VERSION) {
+    return true;
+  }
+
+  return process.argv.slice(2).some((arg) => arg === "--no-update-check");
+}
+
+function canPromptForUpdate() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+async function promptForUpdate(currentVersion, latestVersion) {
+  const { default: select } = await import("@inquirer/select");
+
+  return await select({
+    message: `NanoAgent ${latestVersion} is available. Update before launch?`,
+    choices: [
+      {
+        name: `Yes, update from ${currentVersion} to ${latestVersion}`,
+        value: true,
+        description: "Downloads the latest NanoAgent CLI binary, then starts nanoai.",
+      },
+      {
+        name: `No, continue with ${currentVersion}`,
+        value: false,
+        description: "Skip this update check and launch the currently installed binary.",
+      },
+    ],
+    default: false,
+    loop: false,
+  });
+}
+
+async function maybeUpdateBinary(binaryPath, options = {}) {
+  const { log = () => {} } = options;
+
+  if (shouldSkipRuntimeUpdateCheck()) {
+    return binaryPath;
+  }
+
+  let latestRelease;
+  try {
+    latestRelease = await fetchLatestRelease();
+  } catch {
+    return binaryPath;
+  }
+
+  if (!latestRelease) {
+    return binaryPath;
+  }
+
+  const currentVersion = readInstalledBinaryVersion(binaryPath) || normalizeVersionText(platform.resolveVersion());
+  if (compareVersions(latestRelease.version, currentVersion) <= 0) {
+    return binaryPath;
+  }
+
+  if (!canPromptForUpdate()) {
+    return binaryPath;
+  }
+
+  let shouldUpdate;
+  try {
+    shouldUpdate = await promptForUpdate(currentVersion, latestRelease.version);
+  } catch {
+    return binaryPath;
+  }
+
+  if (!shouldUpdate) {
+    return binaryPath;
+  }
+
+  log(`Updating NanoAgent CLI to ${latestRelease.tag}...`);
+
+  try {
+    return await ensureBinary({
+      force: true,
+      tag: latestRelease.tag,
+      log,
+    });
+  } catch (error) {
+    const message = error && error.message
+      ? error.message
+      : String(error);
+    log(`Update failed: ${message}`);
+    log("Starting the currently installed NanoAgent CLI instead.");
+    return binaryPath;
+  }
+}
+
+module.exports = {
+  compareVersions,
+  fetchLatestRelease,
+  maybeUpdateBinary,
+  normalizeVersionText,
+  readInstalledBinaryVersion,
+  shouldSkipRuntimeUpdateCheck,
+};

package/bin/nanoai.js

@@ -1,62 +0,0 @@
-#!/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();