@cloudless-ai/node-agent 0.0.2

package/README.md

@@ -0,0 +1,38 @@
+# @cloudless-ai/node-agent
+
+Install and manage the Cloudless AI node agent from npm.
+
+## Install
+
+```bash
+npm install -g @cloudless-ai/node-agent
+```
+
+During install, the script:
+
+1. Detects your OS/CPU architecture.
+2. Installs the matching `cloudless-agent` binary.
+3. On macOS, also installs `CloudlessMenuBar`.
+4. Prompts for your router API key and writes `~/.cloudless/agent.yaml`.
+
+## Commands
+
+```bash
+cloudless-node start
+cloudless-node menubar
+cloudless-node set-api-key
+cloudless-node configure --router http://router-host:8080 --token YOUR_KEY
+cloudless-node paths
+```
+
+## Non-interactive install
+
+```bash
+CLOUDLESS_NODE_API_KEY=your_key CLOUDLESS_ROUTER_URL=http://router-host:8080 npm install -g @cloudless-ai/node-agent
+```
+
+## Notes
+
+- 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.

package/bin/cloudless-node.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+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,
+  promptSecret,
+  writeOrUpdateConfig,
+} = require("../scripts/common");
+
+function usage() {
+  process.stdout.write(`Cloudless AI Node CLI
+
+Usage:
+  cloudless-node start
+  cloudless-node menubar
+  cloudless-node set-api-key
+  cloudless-node configure --router <url> --token <api-key>
+  cloudless-node paths
+`);
+}
+
+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");
+    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 parseFlag(flag) {
+  const idx = process.argv.indexOf(flag);
+  if (idx < 0 || idx + 1 >= process.argv.length) {
+    return "";
+  }
+  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);
+  }
+  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;
+  }
+
+  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;
+  }
+
+  if (command === "set-api-key") {
+    await setAPIKeyFromPrompt();
+    return;
+  }
+
+  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);
+    }
+    writeOrUpdateConfig({ routerURL: router, token });
+    process.stdout.write(`Updated config: ${CONFIG_PATH}\n`);
+    return;
+  }
+
+  if (command === "start") {
+    const agent = requiredBinaryPath(AGENT_BINARY_NAME);
+    run(agent, ["--config", CONFIG_PATH]);
+    return;
+  }
+
+  if (command === "menubar") {
+    if (process.platform !== "darwin") {
+      process.stderr.write("Menu bar app is only available on macOS.\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;
+  }
+
+  usage();
+  process.exit(1);
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error.message}\n`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@cloudless-ai/node-agent",
+  "version": "0.0.2",
+  "description": "Cloudless AI node agent installer and launcher",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cloudless-ai/cloudless-ai.git",
+    "directory": "apps/node-agent/npm"
+  },
+  "bin": {
+    "cloudless-node": "./bin/cloudless-node.js"
+  },
+  "scripts": {
+    "postinstall": "node ./scripts/postinstall.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "README.md"
+  ],
+  "keywords": [
+    "cloudless-ai",
+    "node-agent",
+    "llm",
+    "inference"
+  ]
+}

package/scripts/common.js

@@ -0,0 +1,285 @@
+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();
+const CLOUDLESS_ROOT = path.join(HOME, ".cloudless");
+const BIN_DIR = path.join(CLOUDLESS_ROOT, "bin");
+const CONFIG_PATH = path.join(CLOUDLESS_ROOT, "agent.yaml");
+const AGENT_BINARY_NAME = process.platform === "win32" ? "cloudless-agent.exe" : "cloudless-agent";
+const MENUBAR_BINARY_NAME = process.platform === "win32" ? "CloudlessMenuBar.exe" : "CloudlessMenuBar";
+
+function detectTarget() {
+  const archMap = {
+    x64: "amd64",
+    arm64: "arm64",
+  };
+  const osMap = {
+    darwin: "darwin",
+    linux: "linux",
+    win32: "windows",
+  };
+  const goarch = archMap[process.arch];
+  const goos = osMap[process.platform];
+  if (!goarch || !goos) {
+    throw new Error(`Unsupported platform/arch: ${process.platform}/${process.arch}`);
+  }
+  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);
+  fs.chmodSync(targetPath, 0o755);
+  return targetPath;
+}
+
+function updateRouterConfig(content, { routerURL, token }) {
+  const lines = content.split(/\r?\n/);
+  let routerLine = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (/^\s*router:\s*$/.test(lines[i])) {
+      routerLine = i;
+      break;
+    }
+  }
+
+  if (routerLine === -1) {
+    return `${content.trimEnd()}\n\nrouter:\n  address: "${routerURL}"\n  token: "${token}"\n`;
+  }
+
+  let blockEnd = lines.length;
+  for (let i = routerLine + 1; i < lines.length; i++) {
+    if (/^\S/.test(lines[i])) {
+      blockEnd = i;
+      break;
+    }
+  }
+
+  let addressLine = -1;
+  let tokenLine = -1;
+  for (let i = routerLine + 1; i < blockEnd; i++) {
+    if (/^\s+address:\s*/.test(lines[i])) {
+      addressLine = i;
+    }
+    if (/^\s+token:\s*/.test(lines[i])) {
+      tokenLine = i;
+    }
+  }
+
+  if (addressLine >= 0) {
+    lines[addressLine] = `  address: "${routerURL}"`;
+  } else {
+    lines.splice(routerLine + 1, 0, `  address: "${routerURL}"`);
+    blockEnd += 1;
+    if (tokenLine >= 0) {
+      tokenLine += 1;
+    }
+  }
+
+  if (tokenLine >= 0) {
+    lines[tokenLine] = `  token: "${token}"`;
+  } else {
+    lines.splice(routerLine + 1, 0, `  token: "${token}"`);
+  }
+
+  return `${lines.join("\n").replace(/\s+$/, "")}\n`;
+}
+
+function writeOrUpdateConfig({ routerURL, token }) {
+  let content = defaultAgentConfig(routerURL, token);
+  if (fs.existsSync(CONFIG_PATH)) {
+    const existing = fs.readFileSync(CONFIG_PATH, "utf8");
+    content = updateRouterConfig(existing, { routerURL, token });
+  }
+  fs.writeFileSync(CONFIG_PATH, content, "utf8");
+}
+
+function defaultAgentConfig(routerURL, token) {
+  return `router:
+  address: "${routerURL}"
+  token: "${token}"
+  heartbeat_interval: "10s"
+  system_load_ceiling: 2.5
+  mdns: true
+  mdns_service: "_cloudless-router._tcp"
+  discover_interval: "1m"
+  servers_file: "${HOME}/.cloudless/router-servers.json"
+  manual_servers: []
+
+inference:
+  backend: "llamacpp"
+  llamacpp_host: "http://localhost:8081"
+  models_dir: "${HOME}/.cloudless/models"
+  preload_models: []
+  max_concurrent_requests: 4
+  auto_install_llamacpp: false
+  unload_on_system_load: true
+
+server:
+  port: 9090
+
+observability:
+  log_level: "info"
+  tracing:
+    enabled: false
+    endpoint: "localhost:4318"
+    insecure: true
+    service_name: "cloudless-node-agent"
+    sampling_ratio: 1.0
+`;
+}
+
+function promptSecret(promptText) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return Promise.resolve("");
+  }
+
+  return new Promise((resolve) => {
+    process.stdout.write(promptText);
+    const stdin = process.stdin;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let value = "";
+
+    const onData = (char) => {
+      if (char === "\r" || char === "\n") {
+        process.stdout.write("\n");
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.removeListener("data", onData);
+        resolve(value.trim());
+        return;
+      }
+      if (char === "\u0003") {
+        process.stdout.write("\n");
+        process.exit(130);
+      }
+      if (char === "\u007f") {
+        if (value.length > 0) {
+          value = value.slice(0, -1);
+          process.stdout.write("\b \b");
+        }
+        return;
+      }
+      value += char;
+      process.stdout.write("*");
+    };
+
+    stdin.on("data", onData);
+  });
+}
+
+function promptLine(promptText) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return Promise.resolve("");
+  }
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(promptText, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+module.exports = {
+  AGENT_BINARY_NAME,
+  MENUBAR_BINARY_NAME,
+  BIN_DIR,
+  CONFIG_PATH,
+  CLOUDLESS_ROOT,
+  defaultAgentConfig,
+  detectTarget,
+  ensureDirs,
+  extractArchive,
+  fetchToFile,
+  findFileRecursive,
+  installBinary,
+  normalizeVersion,
+  promptLine,
+  promptSecret,
+  releaseBaseURL,
+  updateRouterConfig,
+  writeOrUpdateConfig,
+};

package/scripts/postinstall.js

@@ -0,0 +1,176 @@
+#!/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");
+  }
+  downloadedSourceRoot = path.join(extractDir, entries[0].name);
+  return downloadedSourceRoot;
+}
+
+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 });
+  }
+}
+
+async function installMenubar(version) {
+  if (process.platform !== "darwin") {
+    return null;
+  }
+  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");
+
+  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}`);
+    }
+    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 });
+  }
+}
+
+async function promptConfig() {
+  const routerURL = process.env.CLOUDLESS_ROUTER_URL?.trim() || "http://localhost:8080";
+  let apiKey = process.env.CLOUDLESS_NODE_API_KEY?.trim() || "";
+  if (!apiKey && process.stdin.isTTY && process.stdout.isTTY) {
+    process.stdout.write("\nCloudless AI node setup\n");
+    process.stdout.write(`Router URL: ${routerURL}\n`);
+    apiKey = await promptSecret("Enter Cloudless router API key (hidden): ");
+  }
+  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");
+    return;
+  }
+  writeOrUpdateConfig({ routerURL, token: apiKey });
+  process.stdout.write(`Saved node config to ${CONFIG_PATH}\n`);
+}
+
+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;
+    }
+  }
+}
+
+main().catch((error) => {
+  process.stderr.write(`Installation failed: ${error.message}\n`);
+  process.exit(1);
+});