@cloudless-ai/node-agent 0.0.2 → 0.0.13

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`.
 
@@ -35,4 +35,4 @@ 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.
+- Installation has no GitHub release dependency; binaries are bundled in the npm tarball.

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@cloudless-ai/node-agent",
-  "version": "0.0.2",
+  "version": "0.0.13",
   "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);
@@ -272,14 +199,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() {
@@ -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");
   }
 }
 

package/bin/cloudless-node.js

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