remote-agents 0.1.1 → 0.1.3

package/README.md

@@ -14,7 +14,7 @@ npm install -g remote-agents
 npx remote-agents --help
 ```
 
-Supported platforms: linux x64, macOS x64/arm64, windows x64.
+Supported platforms: linux x64/arm64, macOS x64/arm64, windows x64.
 
 ## Use as an MCP server
 
@@ -35,9 +35,22 @@ Supported platforms: linux x64, macOS x64/arm64, windows x64.
 ```
 
 `remote-agents <subcommand>` forwards to the native binary (`run`, `mcp`,
-`install`, …). See the [project README](https://github.com/ObsidianMotorman/tunshell_mcp_agents#readme)
+`install`, …). See the [project README](https://github.com/47-ronn/tunshell_mcp_agents#readme)
 for the full documentation.
 
+## Update checks
+
+When started in a long-running mode (`run` / `mcp` / `hybrid`), the launcher does
+a best-effort check against the npm registry and logs a notice if a newer
+version is published. It is **notify-only** — the agent never self-updates, so a
+running task is never interrupted. Update at your convenience with:
+
+```bash
+npm i -g remote-agents@latest
+```
+
+Set `REMOTE_AGENTS_NO_UPDATE_CHECK=1` to disable the check entirely.
+
 ## License
 
 MIT

package/install.js

@@ -7,12 +7,11 @@ const path = require("path");
 const https = require("https");
 const { version } = require("./package.json");
 
-const REPO = "ObsidianMotorman/tunshell_mcp_agents";
+const REPO = "47-ronn/tunshell_mcp_agents";
 
-function target() {
-  const p = process.platform;
-  const a = process.arch;
+function target(p = process.platform, a = process.arch) {
   if (p === "linux" && a === "x64") return { triple: "x86_64-unknown-linux-musl", exe: "" };
+  if (p === "linux" && a === "arm64") return { triple: "aarch64-unknown-linux-musl", exe: "" };
   if (p === "darwin" && a === "x64") return { triple: "x86_64-apple-darwin", exe: "" };
   if (p === "darwin" && a === "arm64") return { triple: "aarch64-apple-darwin", exe: "" };
   if (p === "win32" && a === "x64") return { triple: "x86_64-pc-windows-msvc", exe: ".exe" };
@@ -41,6 +40,27 @@ function download(url, dest, redirects = 0) {
   });
 }
 
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// Retry transient download failures (flaky networks / CDN hiccups) with a small
+// linear backoff. `doDownload`/`wait` are injectable for testing.
+async function downloadWithRetry(url, dest, attempts = 3, doDownload = download, wait = sleep) {
+  let lastErr;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      await doDownload(url, dest);
+      return;
+    } catch (e) {
+      lastErr = e;
+      if (i < attempts - 1) {
+        console.error(`remote-agents: download attempt ${i + 1} failed (${e.message}); retrying…`);
+        await wait(500 * (i + 1));
+      }
+    }
+  }
+  throw lastErr;
+}
+
 async function main() {
   // Escape hatch for CI / source installs where no matching release exists.
   if (process.env.REMOTE_AGENTS_SKIP_DOWNLOAD) {
@@ -52,7 +72,7 @@ async function main() {
   if (!t) {
     console.error(
       `remote-agents: no prebuilt binary for ${process.platform}/${process.arch}.\n` +
-        `  Supported: linux x64, macOS x64/arm64, windows x64.\n` +
+        `  Supported: linux x64/arm64, macOS x64/arm64, windows x64.\n` +
         `  Build from source: https://github.com/${REPO}`
     );
     process.exit(1);
@@ -66,7 +86,7 @@ async function main() {
 
   console.log(`remote-agents: downloading ${asset} (v${version})…`);
   try {
-    await download(url, dest);
+    await downloadWithRetry(url, dest);
     if (!t.exe) fs.chmodSync(dest, 0o755);
     console.log(`remote-agents: installed ${dest}`);
   } catch (e) {
@@ -77,4 +97,9 @@ async function main() {
   }
 }
 
-main();
+// Only download when run as the postinstall script, not when require()'d by tests.
+if (require.main === module) {
+  main();
+}
+
+module.exports = { target, downloadWithRetry };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-agents",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Unified MCP server for controlling fleets of remote machines through AI agents (Claude, opencode)",
   "keywords": [
     "mcp",
@@ -11,10 +11,10 @@
     "ssh",
     "devops"
   ],
-  "homepage": "https://github.com/ObsidianMotorman/tunshell_mcp_agents#readme",
+  "homepage": "https://github.com/47-ronn/tunshell_mcp_agents#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ObsidianMotorman/tunshell_mcp_agents.git"
+    "url": "git+https://github.com/47-ronn/tunshell_mcp_agents.git"
   },
   "license": "MIT",
   "author": "47-ron",

package/run.js

@@ -2,50 +2,198 @@
 // Launcher: exec the downloaded native `remote-agent` binary, forwarding args,
 // stdin/stdout/stderr, termination signals, and exit code.
 // `remote-agents <cmd>` == `remote-agent <cmd>`.
+//
+// On startup of a long-running mode it also does a best-effort npm-registry
+// version check and logs a notice if a newer release is published. This is
+// NOTIFY-ONLY: the agent never self-updates (updating mid-task would interrupt
+// it); the operator runs `npm i -g remote-agents@latest` when convenient.
 
 const path = require("path");
 const fs = require("fs");
 const os = require("os");
+const https = require("https");
 const { spawn } = require("child_process");
+const { version } = require("./package.json");
 
-const exe = process.platform === "win32" ? ".exe" : "";
-const bin = path.join(__dirname, "bin", `remote-agent${exe}`);
-
-if (!fs.existsSync(bin)) {
-  console.error(
-    "remote-agents: native binary not found.\n" +
-      "  Reinstall it with: npm install -g remote-agents  (re-runs the download)."
-  );
-  process.exit(1);
-}
-
-const child = spawn(bin, process.argv.slice(2), { stdio: "inherit" });
-
-// Forward termination signals so stopping this launcher also stops the agent
-// (spawnSync used to orphan the native process).
-const SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"];
-for (const sig of SIGNALS) {
-  process.on(sig, () => {
-    if (!child.killed) {
-      try {
-        child.kill(sig);
-      } catch {
-        /* child already gone */
+const REGISTRY_URL = "https://registry.npmjs.org/remote-agents/latest";
+// Only the long-running modes are worth a version check; one-shot subcommands
+// (init/config/install/...) start and exit, so a notice there is just noise.
+const LONG_RUNNING = new Set(["run", "mcp", "hybrid"]);
+
+// True if dotted version string `latest` is strictly greater than `current`.
+// Non-numeric / missing segments are treated as 0 (best-effort, no semver dep).
+function isNewer(latest, current) {
+  const parse = (s) => String(s).split(".").map((n) => parseInt(n, 10) || 0);
+  const a = parse(latest);
+  const b = parse(current);
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const x = a[i] || 0;
+    const y = b[i] || 0;
+    if (x > y) return true;
+    if (x < y) return false;
+  }
+  return false;
+}
+
+// A human-readable upgrade notice if `latest` is newer than `current`, else null.
+function updateNotice(current, latest) {
+  if (latest && isNewer(latest, current)) {
+    return (
+      `remote-agents: a newer version is available (${current} -> ${latest}). ` +
+      `Update with: npm i -g remote-agents@latest`
+    );
+  }
+  return null;
+}
+
+// Best-effort GET of the registry's `latest` document. Resolves the parsed JSON
+// or rejects; callers swallow errors (an update check must never break startup).
+function httpGetJson(url, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(
+      url,
+      { headers: { "User-Agent": "remote-agents-updatecheck" } },
+      (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          return reject(new Error(`HTTP ${res.statusCode}`));
+        }
+        let data = "";
+        res.setEncoding("utf8");
+        res.on("data", (c) => (data += c));
+        res.on("end", () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            reject(e);
+          }
+        });
       }
-    }
+    );
+    req.on("error", reject);
+    req.setTimeout(timeoutMs, () => req.destroy(new Error("timeout")));
   });
 }
 
-child.on("error", (err) => {
-  console.error(`remote-agents: failed to launch binary: ${err.message}`);
-  process.exit(1);
-});
+// Resolve the latest published version string, or null on any failure. `doGet`
+// is injectable for tests.
+function fetchLatestVersion(doGet = httpGetJson, timeoutMs = 3000) {
+  return doGet(REGISTRY_URL, timeoutMs)
+    .then((json) => (json && typeof json.version === "string" ? json.version : null))
+    .catch(() => null);
+}
+
+// Platform data directory, mirroring Rust's `dirs::data_dir()` so the native
+// agent reads the same cache file: Linux XDG, macOS Application Support,
+// Windows Roaming AppData.
+function dataDir() {
+  if (process.platform === "win32") {
+    return process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+  }
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support");
+  }
+  return process.env.XDG_DATA_HOME || path.join(os.homedir(), ".local", "share");
+}
 
-child.on("exit", (code, signal) => {
-  if (signal) {
-    // Mirror the child's signal in our exit status (128 + signum).
-    const num = (os.constants.signals && os.constants.signals[signal]) || 15;
-    process.exit(128 + num);
+// Where the latest-known version is cached for the native agent to read and
+// surface as AgentInfo.update_available.
+function latestVersionPath() {
+  return path.join(dataDir(), "remote-agents", "latest-version");
+}
+
+// Best-effort write of the update-available cache for the native agent to read
+// (surfaced as AgentInfo.update_available). The launcher owns the comparison —
+// it knows the accurate INSTALLED version (the compiled-in Cargo version can lag
+// the npm release) — so it writes the newer version when an upgrade exists and
+// clears the file (empty) once up to date. Never throws. `writeFile`/`mkdir`
+// are injectable for tests.
+function cacheUpdateAvailable(
+  latest,
+  current = version,
+  file = latestVersionPath(),
+  writeFile = fs.writeFileSync,
+  mkdir = fs.mkdirSync
+) {
+  const body = latest && isNewer(latest, current) ? String(latest) : "";
+  try {
+    mkdir(path.dirname(file), { recursive: true });
+    writeFile(file, body);
+  } catch {
+    /* cache is best-effort; the notify-only log still fires */
   }
-  process.exit(code === null ? 1 : code);
-});
+}
+
+// Fire-and-forget: log an upgrade notice for long-running modes. Never throws,
+// never blocks the agent. Disable with REMOTE_AGENTS_NO_UPDATE_CHECK=1.
+async function maybeNotifyUpdate(subcommand, fetchLatest = fetchLatestVersion) {
+  if (process.env.REMOTE_AGENTS_NO_UPDATE_CHECK) return;
+  if (!LONG_RUNNING.has(subcommand)) return;
+  const latest = await fetchLatest();
+  // Cache the result so the native agent can surface it as
+  // AgentInfo.update_available (visible in list_agents).
+  cacheUpdateAvailable(latest);
+  const notice = updateNotice(version, latest);
+  if (notice) console.error(notice);
+}
+
+function main() {
+  const exe = process.platform === "win32" ? ".exe" : "";
+  const bin = path.join(__dirname, "bin", `remote-agent${exe}`);
+
+  if (!fs.existsSync(bin)) {
+    console.error(
+      "remote-agents: native binary not found.\n" +
+        "  Reinstall it with: npm install -g remote-agents  (re-runs the download)."
+    );
+    process.exit(1);
+  }
+
+  const child = spawn(bin, process.argv.slice(2), { stdio: "inherit" });
+
+  // Best-effort, non-blocking update check (notify-only).
+  maybeNotifyUpdate(process.argv[2]).catch(() => {});
+
+  // Forward termination signals so stopping this launcher also stops the agent
+  // (spawnSync used to orphan the native process).
+  const SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"];
+  for (const sig of SIGNALS) {
+    process.on(sig, () => {
+      if (!child.killed) {
+        try {
+          child.kill(sig);
+        } catch {
+          /* child already gone */
+        }
+      }
+    });
+  }
+
+  child.on("error", (err) => {
+    console.error(`remote-agents: failed to launch binary: ${err.message}`);
+    process.exit(1);
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      // Mirror the child's signal in our exit status (128 + signum).
+      const num = (os.constants.signals && os.constants.signals[signal]) || 15;
+      process.exit(128 + num);
+    }
+    process.exit(code === null ? 1 : code);
+  });
+}
+
+// Only launch when invoked directly, not when require()'d by tests.
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  isNewer,
+  updateNotice,
+  fetchLatestVersion,
+  maybeNotifyUpdate,
+  cacheUpdateAvailable,
+  latestVersionPath,
+};