apteva 0.11.2 → 0.12.1

package/cli.js

@@ -1,6 +1,26 @@
 #!/usr/bin/env node
 "use strict";
 
+// cli.js — npm shim. The user runs `apteva` (or `npx apteva`); npm
+// resolves it to this file via package.json's "bin" field, and we
+// hand off to the Go binary.
+//
+// Path resolution order:
+//
+//   1. ~/.apteva/bin/apteva — the load-bearing symlink chain that
+//      `apteva update` flips. Preferred so `apteva update` followed
+//      by re-running `apteva` actually picks up the new version
+//      (vs running the stale __dirname copy from npm's install).
+//
+//   2. __dirname/apteva — the defensive copy install.js drops into
+//      npm's package install dir. Fallback for environments where
+//      ~/.apteva can't host symlinks (CI, restricted containers,
+//      Windows without elevated privileges).
+//
+// APTEVA_SERVER_BIN / APTEVA_CORE_BIN propagate to the Go process
+// so its findServerBinary / findCoreBinary helpers prefer the
+// symlinked siblings rather than re-resolving against $PATH.
+
 const os = require("os");
 const path = require("path");
 const fs = require("fs");
@@ -8,29 +28,44 @@ const { spawnSync } = require("child_process");
 
 const ext = os.platform() === "win32" ? ".exe" : "";
 const DIR = __dirname;
+const APTEVA_HOME = process.env.APTEVA_HOME || path.join(os.homedir(), ".apteva");
+const SYMLINKED_BIN_DIR = path.join(APTEVA_HOME, "bin");
+
+function resolveBin(name) {
+  const linked = path.join(SYMLINKED_BIN_DIR, `${name}${ext}`);
+  // Use the symlink path even if the target is missing — when
+  // present, it's the canonical "active version" pointer that
+  // `apteva update` rewrites. fs.existsSync follows symlinks, so
+  // we get a positive hit only when the entire chain resolves.
+  if (fs.existsSync(linked)) return linked;
+  // Fallback: the per-package copy install.js dropped here.
+  const local = path.join(DIR, `${name}${ext}`);
+  if (fs.existsSync(local)) return local;
+  return null;
+}
 
-const aptevaBin = path.join(DIR, `apteva${ext}`);
-const serverBin = path.join(DIR, `apteva-server${ext}`);
-const coreBin = path.join(DIR, `apteva-core${ext}`);
+const aptevaBin = resolveBin("apteva");
+const serverBin = resolveBin("apteva-server");
+const coreBin = resolveBin("apteva-core");
 
-if (!fs.existsSync(aptevaBin)) {
-  console.error(`apteva: binary not found at ${aptevaBin}`);
+if (!aptevaBin) {
+  console.error("apteva: binary not found — symlinks at ~/.apteva/bin/ and the npm install dir are both empty.");
   console.error("Try: npm install -g apteva");
   process.exit(1);
 }
-if (!fs.existsSync(serverBin)) {
-  console.error(`apteva: warning - server binary not found at ${serverBin}`);
+if (!serverBin) {
+  console.error(`apteva: warning - server binary not found`);
 }
-if (!fs.existsSync(coreBin)) {
-  console.error(`apteva: warning - core binary not found at ${coreBin}`);
+if (!coreBin) {
+  console.error(`apteva: warning - core binary not found`);
 }
 
 const result = spawnSync(aptevaBin, process.argv.slice(2), {
   stdio: "inherit",
   env: {
     ...process.env,
-    APTEVA_SERVER_BIN: serverBin,
-    APTEVA_CORE_BIN: coreBin,
+    APTEVA_SERVER_BIN: serverBin || "",
+    APTEVA_CORE_BIN: coreBin || "",
   },
 });
 

package/install.js

@@ -1,6 +1,27 @@
 #!/usr/bin/env node
 "use strict";
 
+// install.js — npm postinstall hook.
+//
+// Downloads the platform tarball for `apteva@<VERSION>` from
+// GitHub releases and unpacks it into ~/.apteva/versions/<VERSION>/.
+// Sets up the symlink chain
+//
+//   ~/.apteva/bin/current      → ../versions/<VERSION>
+//   ~/.apteva/bin/apteva       → current/apteva
+//   ~/.apteva/bin/apteva-server → current/apteva-server
+//   ~/.apteva/bin/apteva-core  → current/apteva-core
+//
+// so cli.js (and `apteva update`'s atomic-flip path, and any systemd
+// unit that points at ~/.apteva/bin/apteva-server) all resolve to
+// the right binary regardless of which version is "active".
+//
+// Pre-v0.12, the layout was ~/.apteva/bin/<v>/<binaries> and the
+// install dir held its own copies. We still drop copies into the
+// install dir as a defensive fallback — cli.js prefers the symlink
+// path but falls back to __dirname for environments where home
+// isn't writable (CI, restricted containers, etc).
+
 const os = require("os");
 const fs = require("fs");
 const path = require("path");
@@ -15,6 +36,17 @@ const DIR = __dirname;
 const PLATFORM_MAP = { linux: "linux", darwin: "darwin", win32: "windows" };
 const ARCH_MAP = { x64: "amd64", arm64: "arm64" };
 
+// Path helpers — mirror layout.go in the apteva CLI. Kept in sync
+// by hand; both files are short and the shape is fixed.
+const APTEVA_HOME = process.env.APTEVA_HOME || path.join(os.homedir(), ".apteva");
+const VERSIONS_DIR = path.join(APTEVA_HOME, "versions");
+const BIN_DIR = path.join(APTEVA_HOME, "bin");
+const RELEASES_DIR = path.join(APTEVA_HOME, "releases");
+const VERSION_DIR = path.join(VERSIONS_DIR, VERSION);
+const CURRENT_LINK = path.join(BIN_DIR, "current");
+
+const BIN_NAMES = ["apteva", "apteva-server", "apteva-core"];
+
 function download(url) {
   return new Promise((resolve, reject) => {
     const follow = (url, redirects) => {
@@ -39,6 +71,33 @@ function download(url) {
   });
 }
 
+// pointSymlinks (re)creates the bin/ symlink chain pointing at
+// VERSION_DIR. Idempotent — running it twice is a no-op. Mirrors
+// the Go-side pointSymlinks() in apteva/layout.go; we duplicate it
+// here so npm's postinstall doesn't need a Go runtime.
+function pointSymlinks() {
+  fs.mkdirSync(BIN_DIR, { recursive: true });
+
+  // current → ../versions/<VERSION>. Relative target keeps the
+  // tree portable (move ~/.apteva to a different host home and it
+  // still resolves).
+  const relTarget = path.join("..", "versions", VERSION);
+  const tmp = CURRENT_LINK + ".tmp";
+  try { fs.unlinkSync(tmp); } catch {}
+  fs.symlinkSync(relTarget, tmp);
+  // POSIX-atomic rename onto current.
+  fs.renameSync(tmp, CURRENT_LINK);
+
+  // Per-binary shims: bin/<name> → current/<name>. Replace if
+  // already present — old shims pointing at a since-deleted version
+  // dir would fail to resolve.
+  for (const name of BIN_NAMES) {
+    const dst = path.join(BIN_DIR, name);
+    try { fs.unlinkSync(dst); } catch {}
+    fs.symlinkSync(path.join("current", name), dst);
+  }
+}
+
 async function main() {
   const platform = PLATFORM_MAP[os.platform()];
   const arch = ARCH_MAP[os.arch()];
@@ -46,23 +105,25 @@ async function main() {
     console.error(`apteva: unsupported platform ${os.platform()}-${os.arch()}`);
     process.exit(1);
   }
-
-  // Cache binaries in ~/.apteva/bin/<version>/ so repeated npx runs are instant
-  const cacheDir = path.join(os.homedir(), ".apteva", "bin", VERSION);
   const ext = platform === "windows" ? ".exe" : "";
-  const cachedBin = path.join(cacheDir, `apteva${ext}`);
 
-  if (fs.existsSync(cachedBin)) {
-    // Copy from cache to install dir
-    for (const name of ["apteva", "apteva-server", "apteva-core"]) {
-      const src = path.join(cacheDir, `${name}${ext}`);
+  // If versions/<VERSION>/ already has our binaries (cached from
+  // a prior npx install of the same version), just point the
+  // symlinks and stash a defensive copy in DIR. No download.
+  const cachedAptevaBin = path.join(VERSION_DIR, `apteva${ext}`);
+  if (fs.existsSync(cachedAptevaBin)) {
+    if (platform !== "windows") {
+      try { pointSymlinks(); } catch (e) { /* non-fatal */ }
+    }
+    for (const name of BIN_NAMES) {
+      const src = path.join(VERSION_DIR, `${name}${ext}`);
       const dst = path.join(DIR, `${name}${ext}`);
       if (fs.existsSync(src)) {
         fs.copyFileSync(src, dst);
         if (platform !== "windows") fs.chmodSync(dst, 0o755);
       }
     }
-    console.log(`apteva: v${VERSION} loaded from cache.`);
+    console.log(`apteva: v${VERSION} loaded from ~/.apteva/versions/${VERSION}/`);
     return;
   }
 
@@ -73,36 +134,53 @@ async function main() {
 
   try {
     const buffer = await download(url);
-    const tmpFile = path.join(DIR, "_download.tar.gz");
-    fs.writeFileSync(tmpFile, buffer);
+
+    // Stash the tarball in releases/ so future flake-recovery
+    // paths can reuse it without re-downloading.
+    fs.mkdirSync(RELEASES_DIR, { recursive: true });
+    const releasePath = path.join(RELEASES_DIR, tarName);
+    fs.writeFileSync(releasePath, buffer);
 
     console.log(`apteva: extracting (${(buffer.length / 1024 / 1024).toFixed(1)} MB)...`);
-    execSync(`tar -xzf "${tmpFile}" -C "${DIR}"`, { stdio: "pipe" });
-    fs.unlinkSync(tmpFile);
+    fs.mkdirSync(VERSION_DIR, { recursive: true });
+    execSync(`tar -xzf "${releasePath}" -C "${VERSION_DIR}"`, { stdio: "pipe" });
 
-    // Make binaries executable
     if (platform !== "windows") {
-      for (const name of ["apteva", "apteva-server", "apteva-core"]) {
-        const bin = path.join(DIR, name);
+      for (const name of BIN_NAMES) {
+        const bin = path.join(VERSION_DIR, name);
         if (fs.existsSync(bin)) fs.chmodSync(bin, 0o755);
       }
     }
 
-    // Save to cache for next run
-    fs.mkdirSync(cacheDir, { recursive: true });
-    for (const name of ["apteva", "apteva-server", "apteva-core"]) {
-      const src = path.join(DIR, `${name}${ext}`);
-      const dst = path.join(cacheDir, `${name}${ext}`);
-      if (fs.existsSync(src)) fs.copyFileSync(src, dst);
+    // Set up the symlink chain pointing at this version. Skip on
+    // Windows where symlinks need elevated privileges.
+    if (platform !== "windows") {
+      try { pointSymlinks(); }
+      catch (e) {
+        console.warn(`apteva: symlink setup failed: ${e.message}`);
+        console.warn("(falling back to per-package install dir; updates won't work without symlinks)");
+      }
+    }
+
+    // Defensive copy into the npm package install dir so cli.js's
+    // fallback path works when ~/.apteva isn't usable.
+    for (const name of BIN_NAMES) {
+      const src = path.join(VERSION_DIR, `${name}${ext}`);
+      const dst = path.join(DIR, `${name}${ext}`);
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, dst);
+        if (platform !== "windows") fs.chmodSync(dst, 0o755);
+      }
     }
 
-    console.log("apteva: installed successfully.");
+    console.log(`apteva: installed to ~/.apteva/versions/${VERSION}/`);
+    console.log("apteva: ready. (run 'apteva' to start, or 'apteva service install' for a background service)");
   } catch (err) {
     console.error(`apteva: binary download failed: ${err.message}`);
     console.error("");
     console.error("Falling back to local Go build...");
 
-    // Fallback: build from source if Go is available
+    // Fallback: build from source if Go is available.
     try {
       execSync("go version", { stdio: "pipe" });
       console.log("apteva: building from source...");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apteva",
-  "version": "0.11.2",
+  "version": "0.12.1",
   "description": "AI agent platform with multi-thread orchestration, MCP integrations, and dashboard",
   "bin": {
     "apteva": "./cli.js"