@cloudless-ai/node-agent 0.0.2 → 0.0.14

package/README.md

@@ -11,7 +11,7 @@ npm install -g @cloudless-ai/node-agent
 During install, the script:
 
 1. Detects your OS/CPU architecture.
-2. Installs the matching `cloudless-agent` binary.
+2. Installs the matching precompiled binary bundled in this package.
 3. On macOS, also installs `CloudlessMenuBar`.
 4. Prompts for your router API key and writes `~/.cloudless/agent.yaml`.
 
@@ -19,10 +19,11 @@ During install, the script:
 
 ```bash
 cloudless-node start
+cloudless-node start --interactive
 cloudless-node menubar
+cloudless-node stop
 cloudless-node set-api-key
-cloudless-node configure --router http://router-host:8080 --token YOUR_KEY
-cloudless-node paths
+cloudless-node configure
 ```
 
 ## Non-interactive install
@@ -35,4 +36,7 @@ CLOUDLESS_NODE_API_KEY=your_key CLOUDLESS_ROUTER_URL=http://router-host:8080 npm
 
 - By default binaries are installed to `~/.cloudless/bin`.
 - Configuration is written to `~/.cloudless/agent.yaml`.
-- Set `CLOUDLESS_RELEASE_BASE_URL` to override release download source.
+- `cloudless-node start` launches the node + menubar in the background by default.
+- Use `cloudless-node start --interactive` to keep it attached to your terminal.
+- Installation has no GitHub release dependency; binaries are bundled in the npm tarball.
+- For internet demos, set `router.advertise_address` in `~/.cloudless/agent.yaml` (or `CLOUDLESS_AGENT_ADVERTISE_ADDRESS`) to a public tunnel URL so router/dashboard can reach this node.

package/bin/cloudless-node.js

@@ -1,121 +1,255 @@
 #!/usr/bin/env node
+const { spawn, spawnSync } = require("node:child_process");
 const fs = require("node:fs");
-const { spawnSync } = require("node:child_process");
 const path = require("node:path");
 
 const {
   AGENT_BINARY_NAME,
   MENUBAR_BINARY_NAME,
   BIN_DIR,
-  CONFIG_PATH,
+  CLOUDLESS_ROOT,
   promptSecret,
+  promptLine,
   writeOrUpdateConfig,
+  CONFIG_PATH,
 } = require("../scripts/common");
 
-function usage() {
-  process.stdout.write(`Cloudless AI Node CLI
+const agentBin = path.join(BIN_DIR, AGENT_BINARY_NAME);
+const menubarBin = path.join(BIN_DIR, MENUBAR_BINARY_NAME);
+const supervisorPidFile = path.join(CLOUDLESS_ROOT, "cloudless-node-supervisor.pid");
 
-Usage:
-  cloudless-node start
-  cloudless-node menubar
-  cloudless-node set-api-key
-  cloudless-node configure --router <url> --token <api-key>
-  cloudless-node paths
-`);
+function withDefaultConfig(args) {
+  const hasConfigArg = args.includes("--config");
+  if (hasConfigArg) {
+    return args;
+  }
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return args;
+  }
+  return [...args, "--config", CONFIG_PATH];
 }
 
-function requiredBinaryPath(name) {
-  const fullPath = path.join(BIN_DIR, name);
-  if (!fs.existsSync(fullPath)) {
-    process.stderr.write(`Binary not found: ${fullPath}\n`);
-    process.stderr.write("Reinstall package: npm install -g @cloudless-ai/node-agent\n");
+function checkBinary(bin) {
+  if (!fs.existsSync(bin)) {
+    process.stderr.write(
+      `cloudless-node: binary not found at ${bin}\n` +
+      `Re-run \`npm install -g @cloudless-ai/node-agent\` to reinstall.\n`
+    );
     process.exit(1);
   }
-  return fullPath;
 }
 
-function run(command, args, extraEnv = {}) {
-  const result = spawnSync(command, args, {
-    stdio: "inherit",
-    env: { ...process.env, ...extraEnv },
-  });
-  process.exit(result.status ?? 1);
+function runBinary(bin, args) {
+  checkBinary(bin);
+  const result = spawnSync(bin, withDefaultConfig(args), { stdio: "inherit" });
+  if (result.error) {
+    process.stderr.write(`cloudless-node: ${result.error.message}\n`);
+    process.exit(1);
+  }
+  process.exit(result.status ?? 0);
 }
 
-function parseFlag(flag) {
-  const idx = process.argv.indexOf(flag);
-  if (idx < 0 || idx + 1 >= process.argv.length) {
-    return "";
+function stopProcess(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
   }
-  return process.argv[idx + 1];
 }
 
-async function setAPIKeyFromPrompt() {
-  const token = await promptSecret("Enter Cloudless router API key (hidden): ");
-  if (!token) {
-    process.stderr.write("No API key provided.\n");
-    process.exit(1);
+function readSupervisorPid() {
+  if (!fs.existsSync(supervisorPidFile)) {
+    return null;
+  }
+  const raw = fs.readFileSync(supervisorPidFile, "utf8").trim();
+  if (!raw) {
+    return null;
+  }
+  const pid = Number(raw);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null;
+  }
+  try {
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    return null;
   }
-  const routerURL = process.env.CLOUDLESS_ROUTER_URL?.trim() || "http://localhost:8080";
-  writeOrUpdateConfig({ routerURL, token });
-  process.stdout.write(`Updated API key in ${CONFIG_PATH}\n`);
 }
 
-async function main() {
-  const command = process.argv[2] ?? "help";
-  if (command === "help" || command === "--help" || command === "-h") {
-    usage();
-    return;
+function writeSupervisorPid() {
+  fs.mkdirSync(path.dirname(supervisorPidFile), { recursive: true });
+  fs.writeFileSync(supervisorPidFile, `${process.pid}\n`, "utf8");
+}
+
+function clearSupervisorPid() {
+  try {
+    fs.unlinkSync(supervisorPidFile);
+  } catch {}
+}
+
+function runSupervisor(agentArgs) {
+  checkBinary(agentBin);
+
+  const isMac = process.platform === "darwin";
+  const startTime = Date.now();
+
+  const agent = spawn(agentBin, withDefaultConfig(agentArgs), { stdio: "inherit" });
+
+  let menubar = null;
+  if (isMac) {
+    if (fs.existsSync(menubarBin)) {
+      menubar = spawn(menubarBin, [], { stdio: "ignore" });
+    }
   }
 
-  if (command === "paths") {
-    process.stdout.write(`Agent binary: ${path.join(BIN_DIR, AGENT_BINARY_NAME)}\n`);
-    process.stdout.write(`Menu bar binary: ${path.join(BIN_DIR, MENUBAR_BINARY_NAME)}\n`);
-    process.stdout.write(`Config: ${CONFIG_PATH}\n`);
-    return;
+  writeSupervisorPid();
+
+  let shuttingDown = false;
+  function shutdown() {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    agent.kill();
+    if (menubar) menubar.kill();
   }
 
-  if (command === "set-api-key") {
-    await setAPIKeyFromPrompt();
-    return;
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("exit", clearSupervisorPid);
+
+  agent.on("exit", (code) => {
+    const exitedQuickly = Date.now() - startTime < 5000;
+    if (menubar && code !== 0 && code !== null && exitedQuickly) {
+      process.stderr.write(
+        "cloudless-node: agent failed to start, keeping menubar attached to existing local agent if available\n"
+      );
+      return;
+    }
+    if (menubar) menubar.kill();
+    clearSupervisorPid();
+    process.exit(code ?? 0);
+  });
+
+  if (menubar) {
+    menubar.on("exit", () => {
+      agent.kill();
+      clearSupervisorPid();
+      process.exit(0);
+    });
+    menubar.on("exit", (code) => {
+      if (code !== 0 && code !== null) {
+        process.stderr.write(`cloudless-node: menubar exited with code ${code}\n`);
+      }
+    });
   }
+}
 
-  if (command === "configure") {
-    const router = parseFlag("--router") || process.env.CLOUDLESS_ROUTER_URL || "http://localhost:8080";
-    const token = parseFlag("--token") || process.env.CLOUDLESS_NODE_API_KEY || "";
-    if (!token) {
-      process.stderr.write("Missing API key. Use --token or CLOUDLESS_NODE_API_KEY.\n");
-      process.exit(1);
+function parseStartArgs(args) {
+  let interactive = false;
+  const agentArgs = [];
+  for (const arg of args) {
+    if (arg === "--interactive") {
+      interactive = true;
+      continue;
     }
-    writeOrUpdateConfig({ routerURL: router, token });
-    process.stdout.write(`Updated config: ${CONFIG_PATH}\n`);
+    agentArgs.push(arg);
+  }
+  return { interactive, agentArgs };
+}
+
+function startDetached(agentArgs) {
+  const existing = readSupervisorPid();
+  if (existing) {
+    process.stdout.write(`cloudless-node: already running (supervisor pid ${existing})\n`);
     return;
   }
+  const child = spawn(process.execPath, [__filename, "run-supervised", ...agentArgs], {
+    detached: true,
+    stdio: "ignore",
+  });
+  child.unref();
+  process.stdout.write(`cloudless-node: started in background (supervisor pid ${child.pid})\n`);
+}
 
-  if (command === "start") {
-    const agent = requiredBinaryPath(AGENT_BINARY_NAME);
-    run(agent, ["--config", CONFIG_PATH]);
+function stopSupervisor() {
+  const pid = readSupervisorPid();
+  if (!pid) {
+    process.stdout.write("cloudless-node: not running\n");
     return;
   }
+  if (!stopProcess(pid)) {
+    clearSupervisorPid();
+    process.stdout.write("cloudless-node: not running\n");
+    return;
+  }
+  process.stdout.write("cloudless-node: stop signal sent\n");
+}
+
+async function configure() {
+  const defaultURL = "http://localhost:8080";
+  process.stdout.write("Cloudless AI node configuration\n\n");
 
-  if (command === "menubar") {
-    if (process.platform !== "darwin") {
-      process.stderr.write("Menu bar app is only available on macOS.\n");
+  const routerURL =
+    (await promptLine(`Router URL [${defaultURL}]: `)) || defaultURL;
+  process.stdout.write(
+    "API key: create a node-scoped key in the Cloudless AI dashboard (Admin → API Keys → node scope).\n"
+  );
+  const apiKey = await promptSecret("Router API key (hidden): ");
+
+  if (!apiKey) {
+    process.stderr.write("API key is required.\n");
+    process.exit(1);
+  }
+
+  writeOrUpdateConfig({ routerURL, token: apiKey });
+  process.stdout.write(`\nConfig saved to ${CONFIG_PATH}\n`);
+  process.stdout.write("Run `cloudless-node start` to launch the node agent.\n");
+}
+
+const [, , cmd, ...rest] = process.argv;
+
+switch (cmd) {
+  case "configure":
+  case "set-api-key":
+    configure().catch((err) => {
+      process.stderr.write(`${err.message}\n`);
       process.exit(1);
-    }
-    const menubar = requiredBinaryPath(MENUBAR_BINARY_NAME);
-    run(menubar, [], {
-      CLOUDLESS_AGENT_CONFIG_PATH: CONFIG_PATH,
-      CLOUDLESS_AGENT_STATUS_URL: process.env.CLOUDLESS_AGENT_STATUS_URL || "http://127.0.0.1:9090/v1/local/status",
     });
-    return;
+    break;
+
+  case "menubar":
+  case "start": {
+    const { interactive, agentArgs } = parseStartArgs(rest);
+    if (interactive) {
+      runSupervisor(agentArgs);
+      break;
+    }
+    startDetached(agentArgs);
+    break;
   }
 
-  usage();
-  process.exit(1);
-}
+  case "run-supervised":
+    runSupervisor(rest);
+    break;
 
-main().catch((error) => {
-  process.stderr.write(`${error.message}\n`);
-  process.exit(1);
-});
+  case "stop":
+    stopSupervisor();
+    break;
+
+  case undefined: {
+    const { interactive, agentArgs } = parseStartArgs(rest);
+    if (interactive) {
+      runSupervisor(agentArgs);
+      break;
+    }
+    startDetached(agentArgs);
+    break;
+  }
+
+  default:
+    // Pass unknown subcommands/flags straight to the agent binary
+    runBinary(agentBin, [cmd, ...rest]);
+}

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@cloudless-ai/node-agent",
-  "version": "0.0.2",
+  "version": "0.0.14",
   "description": "Cloudless AI node agent installer and launcher",
   "license": "MIT",
+  "homepage": "https://cloudless-ai.app",
   "repository": {
     "type": "git",
-    "url": "https://github.com/cloudless-ai/cloudless-ai.git",
-    "directory": "apps/node-agent/npm"
+    "url": "https://github.com/cloudless-ai/node-agent"
   },
   "bin": {
-    "cloudless-node": "./bin/cloudless-node.js"
+    "cloudless-node": "bin/cloudless-node.js"
   },
   "scripts": {
     "postinstall": "node ./scripts/postinstall.js"
@@ -19,6 +19,7 @@
   },
   "files": [
     "bin",
+    "platform",
     "scripts",
     "README.md"
   ],

package/scripts/common.js

@@ -1,8 +1,6 @@
 const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
-const https = require("node:https");
-const { execFileSync } = require("node:child_process");
 const readline = require("node:readline");
 
 const HOME = os.homedir();
@@ -30,82 +28,11 @@ function detectTarget() {
   return { goos, goarch };
 }
 
-function normalizeVersion(rawVersion) {
-  if (!rawVersion) {
-    return "dev";
-  }
-  return rawVersion.startsWith("v") ? rawVersion.slice(1) : rawVersion;
-}
-
-function releaseBaseURL(version) {
-  const override = process.env.CLOUDLESS_RELEASE_BASE_URL;
-  if (override && override.trim()) {
-    return override.trim().replace(/\/+$/, "");
-  }
-  return `https://github.com/cloudless-ai/cloudless-ai/releases/download/v${version}`;
-}
-
 function ensureDirs() {
   fs.mkdirSync(BIN_DIR, { recursive: true });
   fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
 }
 
-function fetchToFile(url, destPath, redirects = 5) {
-  return new Promise((resolve, reject) => {
-    const req = https.get(url, (res) => {
-      const location = res.headers.location;
-      if (location && res.statusCode && res.statusCode >= 300 && res.statusCode < 400) {
-        res.resume();
-        if (redirects <= 0) {
-          reject(new Error(`Too many redirects for ${url}`));
-          return;
-        }
-        fetchToFile(location, destPath, redirects - 1).then(resolve).catch(reject);
-        return;
-      }
-      if (res.statusCode !== 200) {
-        res.resume();
-        reject(new Error(`Download failed (${res.statusCode}) for ${url}`));
-        return;
-      }
-      const out = fs.createWriteStream(destPath);
-      res.pipe(out);
-      out.on("finish", () => {
-        out.close();
-        resolve();
-      });
-      out.on("error", reject);
-    });
-    req.on("error", reject);
-  });
-}
-
-function extractArchive(archivePath, destination) {
-  fs.mkdirSync(destination, { recursive: true });
-  if (archivePath.endsWith(".zip")) {
-    execFileSync("unzip", ["-o", archivePath, "-d", destination], { stdio: "ignore" });
-    return;
-  }
-  execFileSync("tar", ["-xzf", archivePath, "-C", destination], { stdio: "ignore" });
-}
-
-function findFileRecursive(rootDir, fileName) {
-  const entries = fs.readdirSync(rootDir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(rootDir, entry.name);
-    if (entry.isFile() && entry.name === fileName) {
-      return fullPath;
-    }
-    if (entry.isDirectory()) {
-      const found = findFileRecursive(fullPath, fileName);
-      if (found) {
-        return found;
-      }
-    }
-  }
-  return null;
-}
-
 function installBinary(sourcePath, binaryName) {
   const targetPath = path.join(BIN_DIR, binaryName);
   fs.copyFileSync(sourcePath, targetPath);
@@ -185,6 +112,7 @@ function defaultAgentConfig(routerURL, token) {
   discover_interval: "1m"
   servers_file: "${HOME}/.cloudless/router-servers.json"
   manual_servers: []
+  # advertise_address: "https://my-node-demo.example.com"
 
 inference:
   backend: "llamacpp"
@@ -272,14 +200,9 @@ module.exports = {
   defaultAgentConfig,
   detectTarget,
   ensureDirs,
-  extractArchive,
-  fetchToFile,
-  findFileRecursive,
   installBinary,
-  normalizeVersion,
   promptLine,
   promptSecret,
-  releaseBaseURL,
   updateRouterConfig,
   writeOrUpdateConfig,
 };

package/scripts/postinstall.js

@@ -1,128 +1,47 @@
 #!/usr/bin/env node
 const fs = require("node:fs");
 const path = require("node:path");
-const os = require("node:os");
-const { execFileSync } = require("node:child_process");
 
 const {
   AGENT_BINARY_NAME,
   MENUBAR_BINARY_NAME,
-  BIN_DIR,
   CONFIG_PATH,
   detectTarget,
   ensureDirs,
-  extractArchive,
-  fetchToFile,
-  findFileRecursive,
   installBinary,
-  normalizeVersion,
   promptSecret,
-  releaseBaseURL,
   writeOrUpdateConfig,
 } = require("./common");
 
-const pkg = require("../package.json");
-let downloadedSourceRoot = null;
-let downloadedSourceTempDir = null;
-
-async function ensureSourceTree(version) {
-  if (downloadedSourceRoot) {
-    return downloadedSourceRoot;
-  }
-  const localRoot = path.resolve(__dirname, "..", "..");
-  if (fs.existsSync(path.join(localRoot, "go.mod"))) {
-    downloadedSourceRoot = path.resolve(localRoot, "..", "..");
-    return downloadedSourceRoot;
-  }
-  if (version === "dev") {
-    return null;
-  }
-
-  const tarballURL = `https://codeload.github.com/cloudless-ai/cloudless-ai/tar.gz/refs/tags/v${version}`;
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "cloudless-source-"));
-  downloadedSourceTempDir = tempDir;
-  const archivePath = path.join(tempDir, `cloudless-ai-v${version}.tar.gz`);
-  const extractDir = path.join(tempDir, "extract");
-
-  await fetchToFile(tarballURL, archivePath);
-  extractArchive(archivePath, extractDir);
-  const entries = fs.readdirSync(extractDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
-  if (entries.length !== 1) {
-    throw new Error("Unable to locate extracted source directory");
+function resolveBundledPlatformDir(target) {
+  const key = `${target.goos}/${target.goarch}`;
+  const dirName = `${target.goos}-${target.goarch}`;
+  const platformDir = path.resolve(__dirname, "..", "platform", dirName);
+  if (!fs.existsSync(platformDir)) {
+    throw new Error(`Unsupported platform/arch: ${key}`);
   }
-  downloadedSourceRoot = path.join(extractDir, entries[0].name);
-  return downloadedSourceRoot;
+  return platformDir;
 }
 
-async function installAgent(version, target) {
-  const ext = target.goos === "windows" ? ".zip" : ".tar.gz";
-  const archiveName = `cloudless-agent_${version}_${target.goos}_${target.goarch}${ext}`;
-  const url = `${releaseBaseURL(version)}/${archiveName}`;
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "cloudless-agent-"));
-  const archivePath = path.join(tempDir, archiveName);
-  const extractDir = path.join(tempDir, "extract");
-
-  try {
-    await fetchToFile(url, archivePath);
-    extractArchive(archivePath, extractDir);
-    const binary = findFileRecursive(extractDir, AGENT_BINARY_NAME);
-    if (!binary) {
-      throw new Error(`Release archive does not contain ${AGENT_BINARY_NAME}`);
-    }
-    return installBinary(binary, AGENT_BINARY_NAME);
-  } catch (error) {
-    const sourceTree = await ensureSourceTree(version);
-    const sourceRoot = sourceTree ? path.join(sourceTree, "apps", "node-agent") : null;
-    if (!sourceRoot || !fs.existsSync(path.join(sourceRoot, "go.mod"))) {
-      throw error;
-    }
-    execFileSync("go", ["build", "-o", path.join(BIN_DIR, AGENT_BINARY_NAME), "./cmd/agent"], {
-      cwd: sourceRoot,
-      stdio: "inherit",
-    });
-    fs.chmodSync(path.join(BIN_DIR, AGENT_BINARY_NAME), 0o755);
-    return path.join(BIN_DIR, AGENT_BINARY_NAME);
-  } finally {
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  }
-}
+function installFromPlatformPackage(target) {
+  const platformDir = resolveBundledPlatformDir(target);
+  const agentSource = path.join(platformDir, AGENT_BINARY_NAME);
 
-async function installMenubar(version) {
-  if (process.platform !== "darwin") {
-    return null;
+  if (!fs.existsSync(agentSource)) {
+    throw new Error(`Bundled binaries are missing ${AGENT_BINARY_NAME} for ${target.goos}/${target.goarch}`);
   }
-  const archiveName = `CloudlessMenuBar_${version}_darwin_universal.tar.gz`;
-  const url = `${releaseBaseURL(version)}/${archiveName}`;
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "cloudless-menubar-"));
-  const archivePath = path.join(tempDir, archiveName);
-  const extractDir = path.join(tempDir, "extract");
+  const agentPath = installBinary(agentSource, AGENT_BINARY_NAME);
 
-  try {
-    await fetchToFile(url, archivePath);
-    extractArchive(archivePath, extractDir);
-    const binary = findFileRecursive(extractDir, MENUBAR_BINARY_NAME);
-    if (!binary) {
-      throw new Error(`Release archive does not contain ${MENUBAR_BINARY_NAME}`);
+  let menubarPath = null;
+  if (target.goos === "darwin") {
+    const menuBarSource = path.join(platformDir, MENUBAR_BINARY_NAME);
+    if (!fs.existsSync(menuBarSource)) {
+      throw new Error(`Bundled binaries are missing ${MENUBAR_BINARY_NAME} for ${target.goos}/${target.goarch}`);
     }
-    return installBinary(binary, MENUBAR_BINARY_NAME);
-  } catch {
-    const sourceTree = await ensureSourceTree(version);
-    const menubarRoot = sourceTree ? path.join(sourceTree, "apps", "menubar-macos") : null;
-    if (!menubarRoot || !fs.existsSync(path.join(menubarRoot, "Package.swift"))) {
-      return null;
-    }
-    execFileSync("swift", ["build", "-c", "release", "--product", "CloudlessMenuBar"], {
-      cwd: menubarRoot,
-      stdio: "inherit",
-    });
-    const builtBinary = path.join(menubarRoot, ".build", "release", MENUBAR_BINARY_NAME);
-    if (!fs.existsSync(builtBinary)) {
-      return null;
-    }
-    return installBinary(builtBinary, MENUBAR_BINARY_NAME);
-  } finally {
-    fs.rmSync(tempDir, { recursive: true, force: true });
+    menubarPath = installBinary(menuBarSource, MENUBAR_BINARY_NAME);
   }
+
+  return { agentPath, menubarPath };
 }
 
 async function promptConfig() {
@@ -135,7 +54,7 @@ async function promptConfig() {
   }
   if (!apiKey) {
     process.stdout.write("\nNo API key provided during install.\n");
-    process.stdout.write("Run `cloudless-node set-api-key` to configure it later.\n");
+    process.stdout.write("Run `cloudless-node configure` to set up your router URL and API key.\n");
     return;
   }
   writeOrUpdateConfig({ routerURL, token: apiKey });
@@ -143,30 +62,18 @@ async function promptConfig() {
 }
 
 async function main() {
-  try {
-    ensureDirs();
-    const version = normalizeVersion(pkg.version);
-    const target = detectTarget();
-
-    process.stdout.write(`Installing Cloudless node agent for ${target.goos}/${target.goarch}...\n`);
-    const agentPath = await installAgent(version, target);
-    process.stdout.write(`Installed ${agentPath}\n`);
-
-    const menubarPath = await installMenubar(version);
-    if (menubarPath) {
-      process.stdout.write(`Installed ${menubarPath}\n`);
-    }
-
-    await promptConfig();
-    process.stdout.write("Done. Run `cloudless-node start` to launch the node agent.\n");
-    if (process.platform === "darwin") {
-      process.stdout.write("Run `cloudless-node menubar` to start the menu bar app.\n");
-    }
-  } finally {
-    if (downloadedSourceTempDir) {
-      fs.rmSync(downloadedSourceTempDir, { recursive: true, force: true });
-      downloadedSourceTempDir = null;
-    }
+  ensureDirs();
+  const target = detectTarget();
+  process.stdout.write(`Installing Cloudless node agent for ${target.goos}/${target.goarch}...\n`);
+  const result = installFromPlatformPackage(target);
+  process.stdout.write(`Installed ${result.agentPath}\n`);
+  if (result.menubarPath) {
+    process.stdout.write(`Installed ${result.menubarPath}\n`);
+  }
+  await promptConfig();
+  process.stdout.write("Done. Run `cloudless-node start` to launch the node agent.\n");
+  if (target.goos === "darwin") {
+    process.stdout.write("Run `cloudless-node menubar` to start the menu bar app.\n");
   }
 }