@vantaloom/runtime-linux-x64 0.12.48 → 0.12.50

package/cli/src/lib/install.mjs

@@ -0,0 +1,627 @@
+import {
+  appendFileSync,
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs"
+import { cp, writeFile } from "node:fs/promises"
+import { spawnSync } from "node:child_process"
+import os from "node:os"
+import path from "node:path"
+import {
+  LOCK_ERROR_CODES,
+  cliRoot,
+  repoCandidate,
+  installedConfigPath,
+  defaultReleaseTag,
+  defaultRepo,
+  defaultNpmRegistry,
+} from "./constants.mjs"
+import {
+  binaryName,
+  platformId,
+  runtimePackageName,
+  parsePlatformId,
+  fileSha,
+  readJSONIfExists,
+  removeKnownPath,
+  writeText,
+  run,
+  runPnpm,
+  platformToGoEnv,
+} from "./platform.mjs"
+import {
+  meshBinarySet,
+  meshServiceRunning,
+  ensureMeshService,
+  ensureLinuxMeshCapabilities,
+  killTrayProcess,
+} from "./mesh.mjs"
+import {
+  enableRuntimeAutostart,
+} from "./lifecycle.mjs"
+
+// sleepSync blocks for ms milliseconds without async (install runs top-to-bottom
+// and must not race the file copy against a process that is still releasing its
+// handles). Uses Atomics.wait on a throwaway buffer — no busy spin.
+export function sleepSync(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.max(0, ms))
+  } catch {
+    const end = Date.now() + ms
+    while (Date.now() < end) {} // fallback busy-wait if SAB is unavailable
+  }
+}
+
+// copyFileResilient overwrites dst with src, surviving the Windows case where dst
+// is a running/locked executable. Windows refuses to OVERWRITE or DELETE an in-use
+// .exe (EPERM/EBUSY) but DOES allow RENAMING it — the file handle tracks the file
+// object, not its path. So on a lock error we move the locked file aside and copy
+// the new one into the freed path; the runtime picks up the new binary on its next
+// start, and the moved-aside `.old-*` file is reaped on a later install. This is
+// the fix for the EPERM that blocked update/restart when a prior process (api,
+// agent, or an orphaned easytier/mesh) still held a binary open.
+export function copyFileResilient(src, dst) {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      copyFileSync(src, dst)
+      return
+    } catch (err) {
+      if (!LOCK_ERROR_CODES.has(err.code) || !existsSync(dst)) {
+        if (attempt >= 4) throw err
+        sleepSync(250)
+        continue
+      }
+      try {
+        const aside = `${dst}.old-${process.pid}-${attempt}`
+        renameSync(dst, aside)
+        copyFileSync(src, dst)
+        try { rmSync(aside, { force: true }) } catch {} // best-effort; may still be locked
+        return
+      } catch (moveErr) {
+        if (attempt >= 4) throw moveErr
+        sleepSync(300)
+      }
+    }
+  }
+}
+
+// copyDirResilient recursively copies src→dst using copyFileResilient for every
+// file, so a single locked binary can't abort the whole bin/ refresh. filter(srcPath)
+// gates which entries are copied (mirrors fs.cp's filter).
+export function copyDirResilient(src, dst, filter) {
+  mkdirSync(dst, { recursive: true })
+  for (const entry of readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name)
+    if (filter && !filter(s)) continue
+    const d = path.join(dst, entry.name)
+    if (entry.isDirectory()) {
+      copyDirResilient(s, d, filter)
+    } else {
+      copyFileResilient(s, d)
+    }
+  }
+}
+
+// cleanupStaleReplacements deletes the `.old-*` files left behind by a prior
+// lock-safe replace once their handles have been released (best-effort).
+export function cleanupStaleReplacements(dir) {
+  if (!existsSync(dir)) return
+  for (const entry of readdirSync(dir)) {
+    if (/\.old-\d+-\d+$/.test(entry)) {
+      try { rmSync(path.join(dir, entry), { force: true }) } catch {}
+    }
+  }
+}
+
+export async function applyPackage(packageRoot, prefix, options) {
+  assertRuntimePackage(packageRoot)
+
+  const existingConfig = readInstalledConfig(prefix)
+  const packageConfig = readJSONIfExists(path.join(packageRoot, "cli", "config.json"))
+  const mergedConfig = mergeRuntimeConfig(packageConfig, existingConfig, {
+    sourceRoot: options.sourceRoot,
+  })
+  const version = readVersion(packageRoot)
+
+  mkdirSync(prefix, { recursive: true })
+  const existingCtl = path.join(prefix, "bin", binaryName("vantaloomctl"))
+  if (existsSync(existingCtl)) {
+    spawnSync(existingCtl, ["stop", "--prefix", prefix], { stdio: "inherit", windowsHide: true })
+  }
+
+  // Kill lingering tray process that may hold locks on bin/ (older versions
+  // don't write tray.pid, so vantaloomctl stop won't find them).
+  killTrayProcess(prefix)
+
+  // Windows releases a stopped process's file handles asynchronously; copying
+  // bin/ the instant after `stop` can still hit the old exe's lock (EPERM). Give
+  // the OS a moment to close handles, and sweep any `.old-*` files a previous
+  // lock-safe replace left behind (now that those handles are likely released).
+  // copyFileResilient below is the real safety net if a handle is still open.
+  if (existsSync(path.join(prefix, "bin"))) {
+    sleepSync(600)
+    cleanupStaleReplacements(path.join(prefix, "bin"))
+  }
+
+  // On Windows the privileged mesh service holds its binaries open, so we can't
+  // wipe or overwrite them with a plain copy. Detect that up front: if the
+  // service is running, skip those files in the bin/ copy (the elevated `apply`
+  // swaps them after stopping the service).
+  const meshLocked =
+    process.platform === "win32" &&
+    meshServiceRunning(path.join(packageRoot, "bin"), "win32")
+
+  // Copy package contents to install prefix
+  const meshNames = meshBinarySet(process.platform)
+  // "adapters" carries the bundled Claude Code ACP adapter + reclaude shim. Older
+  // packages predate it, so its absence is tolerated (no warning) — bin/web/cli are
+  // still required.
+  const optionalDirs = new Set(["adapters"])
+  for (const name of ["bin", "web", "cli", "adapters"]) {
+    const src = path.join(packageRoot, name)
+    const dst = path.join(prefix, name)
+    if (!existsSync(src)) {
+      if (!optionalDirs.has(name)) {
+        console.error(`  warning: package missing ${name}/ directory`)
+      }
+      continue
+    }
+    const copyOpts = { recursive: true, force: true, dereference: false }
+    if (name === "bin") {
+      // Never wipe bin/: that would drop the running mesh binaries (and, on Linux,
+      // clear easytier-core's setcap capability). Overwrite in place, but SKIP a
+      // mesh binary when the running service holds it open (Windows) OR it is
+      // byte-identical to what's installed. The upshot: an update where the mesh
+      // is unchanged leaves the privileged service entirely untouched, so it needs
+      // no UAC/sudo. Changed mesh binaries and all non-mesh files are copied.
+      copyOpts.filter = (s) => {
+        const base = path.basename(s)
+        if (!meshNames.includes(base)) return true
+        if (meshLocked) return false
+        const installed = path.join(dst, base)
+        return !(existsSync(installed) && fileSha(s) === fileSha(installed))
+      }
+      // bin/ holds the long-lived executables (api, agent, ctl, easytier, mesh).
+      // Copy each file with the lock-safe move-aside replace so a still-locked
+      // binary from a not-fully-exited prior process never aborts the update with
+      // EPERM (the bug that wedged update/restart).
+      copyDirResilient(src, dst, copyOpts.filter)
+      continue
+    } else {
+      removeKnownPath(dst, prefix)
+    }
+    await cp(src, dst, copyOpts)
+  }
+
+  // Ensure binaries are executable on Unix (cross-compiled from Windows they lose +x)
+  const binDir = path.join(prefix, "bin")
+  if (process.platform !== "win32" && existsSync(binDir)) {
+    for (const entry of readdirSync(binDir)) {
+      const binPath = path.join(binDir, entry)
+      try { chmodSync(binPath, 0o755) } catch {}
+    }
+  }
+
+  // Linux: grant easytier-core the TUN capability so the unprivileged runtime can
+  // bring up the mesh virtual network. This is the one privileged step of the
+  // install (a single sudo); the app itself stays unprivileged.
+  ensureLinuxMeshCapabilities(binDir)
+
+  // Windows/macOS: register (or lock-safely update) the privileged mesh service
+  // that runs easytier-core. This is the one elevation of the install on those
+  // platforms. Skipped for --no-start and gated to avoid prompting on every
+  // source rebuild (see ensureMeshService).
+  if (!options.noStart) {
+    ensureMeshService(packageRoot, prefix, {
+      sourceInstall: Boolean(options.sourceRoot),
+      withMesh: Boolean(options.withMesh),
+      skipMesh: Boolean(options.skipMesh),
+    })
+  }
+
+  // Make the runtime start at login/boot (per-user, no elevation). Idempotent.
+  if (!options.noStart && !options.skipAutostart) {
+    enableRuntimeAutostart(prefix)
+  }
+
+  // Verify vantaloomctl binary exists before trying to run it
+  const ctlBin = path.join(prefix, "bin", binaryName("vantaloomctl"))
+  if (!existsSync(ctlBin)) {
+    const binContents = existsSync(binDir) ? readdirSync(binDir) : []
+    const srcBinContents = existsSync(path.join(packageRoot, "bin")) ? readdirSync(path.join(packageRoot, "bin")) : []
+    throw new Error(
+      `vantaloomctl binary not found at ${ctlBin}\n` +
+      `  installed bin/: [${binContents.join(", ")}]\n` +
+      `  package bin/:   [${srcBinContents.join(", ")}]\n` +
+      `  platform: ${platformId()}\n` +
+      `  This may indicate a corrupt download. Try again or install from source.`
+    )
+  }
+
+  await writeLauncher(prefix)
+  await writeText(path.join(prefix, "cli", "config.json"), `${JSON.stringify(mergedConfig, null, 2)}\n`)
+  await writeText(path.join(prefix, "VERSION"), `${version}\n`)
+  await cp(path.join(packageRoot, "manifest.json"), path.join(prefix, "manifest.json"), {
+    force: true,
+  })
+
+  run(ctlBin, [
+    "install",
+    "--prefix",
+    prefix,
+    "--version",
+    version,
+  ])
+
+  if (!options.noStart) {
+    run(ctlBin, [
+      "start",
+      "--prefix",
+      prefix,
+    ])
+  }
+
+  return version
+}
+
+export function assertRuntimePackage(packageRoot) {
+  for (const name of ["bin", "web", "cli", "manifest.json"]) {
+    if (!existsSync(path.join(packageRoot, name))) {
+      throw new Error(`invalid Vantaloom package, missing ${name}: ${packageRoot}`)
+    }
+  }
+}
+
+export function readVersion(packageRoot) {
+  const versionPath = path.join(packageRoot, "VERSION")
+  if (existsSync(versionPath)) {
+    return readFileSync(versionPath, "utf8").trim() || "dev"
+  }
+  const manifest = readJSONIfExists(path.join(packageRoot, "manifest.json"))
+  return manifest.version ?? "dev"
+}
+
+export function readInstalledConfig(prefix) {
+  return readJSONIfExists(path.join(prefix, "cli", "config.json"))
+}
+
+export function mergeRuntimeConfig(packageConfig, existingConfig, overrides) {
+  const merged = { ...packageConfig }
+  for (const key of ["sourceRoot", "remote", "repo", "releaseTag", "runtimePackage", "runtimeVersion", "npmRegistry"]) {
+    if (!merged[key] && existingConfig[key]) {
+      merged[key] = existingConfig[key]
+    }
+  }
+  if (overrides.sourceRoot) {
+    merged.sourceRoot = overrides.sourceRoot
+  }
+  if (overrides.runtimePackage) {
+    merged.runtimePackage = overrides.runtimePackage
+  }
+  if (overrides.runtimeVersion) {
+    merged.runtimeVersion = overrides.runtimeVersion
+  }
+  if (overrides.npmRegistry) {
+    merged.npmRegistry = overrides.npmRegistry
+  }
+  if (!merged.repo) {
+    merged.repo = defaultRepo
+  }
+  if (!merged.releaseTag) {
+    merged.releaseTag = defaultReleaseTag
+  }
+  // Always force runtimePackage to match the running platform — a cross-compiled
+  // package may carry a config for a different platform (e.g. win32 inside darwin).
+  merged.runtimePackage = runtimePackageName(platformId())
+  if (!merged.runtimeVersion) {
+    merged.runtimeVersion = "latest"
+  }
+  if (!merged.npmRegistry) {
+    merged.npmRegistry = defaultNpmRegistry
+  }
+  return merged
+}
+
+export function runtimeConfigFromSource(sourceRoot) {
+  const remote = gitRemoteUrl(sourceRoot)
+  const repo = inferGitHubRepo(remote) || defaultRepo
+  // Inline registry detection to avoid circular dep with registry.mjs
+  let npmRegistry = ""
+  if (process.env.NPM_CONFIG_REGISTRY) {
+    npmRegistry = process.env.npm_config_registry || process.env.NPM_CONFIG_REGISTRY
+  } else if (process.env.npm_config_registry) {
+    npmRegistry = process.env.npm_config_registry
+  } else {
+    try {
+      const npmrcPath = path.join(os.homedir(), ".npmrc")
+      if (existsSync(npmrcPath)) {
+        const content = readFileSync(npmrcPath, "utf8")
+        const match = content.match(/^\s*registry\s*=\s*(.+)/m)
+        if (match) npmRegistry = match[1].trim()
+      }
+    } catch {}
+  }
+  return {
+    ...(process.env.GITHUB_ACTIONS ? {} : { sourceRoot }),
+    ...(remote ? { remote } : {}),
+    repo,
+    releaseTag: defaultReleaseTag,
+    runtimePackage: runtimePackageName(platformId()),
+    runtimeVersion: "latest",
+    npmRegistry: npmRegistry || defaultNpmRegistry,
+  }
+}
+
+export function findSourceRoot(sourceOption) {
+  if (sourceOption) {
+    return assertSourceRoot(path.resolve(sourceOption))
+  }
+  if (process.env.VANTALOOM_SOURCE) {
+    return assertSourceRoot(path.resolve(process.env.VANTALOOM_SOURCE))
+  }
+  if (existsSync(installedConfigPath)) {
+    const config = JSON.parse(readFileSync(installedConfigPath, "utf8"))
+    if (config.sourceRoot) {
+      return assertSourceRoot(path.resolve(config.sourceRoot))
+    }
+  }
+  return assertSourceRoot(repoCandidate)
+}
+
+export function tryFindSourceRoot() {
+  try {
+    return findSourceRoot()
+  } catch {
+    return ""
+  }
+}
+
+export function tryAssertSourceRoot(sourceRoot) {
+  try {
+    return assertSourceRoot(sourceRoot)
+  } catch {
+    return ""
+  }
+}
+
+export function assertSourceRoot(sourceRoot) {
+  if (!existsSync(path.join(sourceRoot, "apps", "api", "go.mod"))) {
+    throw new Error(`not a Vantaloom source root: ${sourceRoot}`)
+  }
+  return sourceRoot
+}
+
+export function gitRemoteUrl(sourceRoot) {
+  const result = spawnSync("git", ["remote", "get-url", "origin"], {
+    cwd: sourceRoot,
+    encoding: "utf8",
+    windowsHide: true,
+  })
+  if (result.status === 0) {
+    return result.stdout.trim()
+  }
+  return ""
+}
+
+export function inferGitHubRepo(remote) {
+  if (!remote) {
+    return ""
+  }
+  const normalized = remote.replace(/\.git$/, "")
+  const httpsMatch = normalized.match(/github\.com[:/]([^/]+\/[^/]+)$/)
+  if (httpsMatch) {
+    return httpsMatch[1]
+  }
+  const sshMatch = normalized.match(/^[^:]+:([^/]+\/[^/]+)$/)
+  return sshMatch?.[1] ?? ""
+}
+
+export async function copyStaticWeb(sourceRoot, buildWeb) {
+  const exportRoot = path.join(sourceRoot, "apps", "vantaloom", "out")
+  if (!existsSync(exportRoot)) {
+    throw new Error(
+      "missing Next static export output; let GitHub CI run production build, or pass --build-web for a local one-off build"
+    )
+  }
+
+  removeKnownPath(buildWeb, path.dirname(buildWeb))
+  await copyDir(exportRoot, buildWeb)
+}
+
+export async function copyCliDirectory(target, sourceRoot, config) {
+  const sourceCliRoot = path.join(sourceRoot, "packages", "cli")
+  if (!existsSync(path.join(sourceCliRoot, "bin", "vantaloom.mjs"))) {
+    throw new Error(`missing source CLI package: ${sourceCliRoot}`)
+  }
+  removeKnownPath(target, path.dirname(target))
+  mkdirSync(target, { recursive: true })
+  await copyDir(sourceCliRoot, target)
+  await writeText(
+    path.join(target, "config.json"),
+    `${JSON.stringify(config, null, 2)}\n`
+  )
+}
+
+// writeLauncher writes the OS launcher script to the install prefix.
+// NOTE: mirrored in Go at apps/desktop/internal/runtime/
+export async function writeLauncher(prefix) {
+  if (process.platform === "win32") {
+    await writeText(
+      path.join(prefix, "vantaloom.cmd"),
+      `@echo off\r\nnode "%~dp0cli\\bin\\vantaloom.mjs" %*\r\n`
+    )
+  } else {
+    const launcher = `#!/usr/bin/env sh\nexec node "$(dirname "$0")/cli/bin/vantaloom.mjs" "$@"\n`
+    const launcherPath = path.join(prefix, "vantaloom")
+    await writeText(launcherPath, launcher)
+    chmodSync(launcherPath, 0o755)
+  }
+}
+
+export async function copyDir(source, destination, options = {}) {
+  if (!existsSync(source)) {
+    throw new Error(`missing source directory: ${source}`)
+  }
+  removeKnownPath(destination, path.dirname(destination))
+  mkdirSync(destination, { recursive: true })
+  await cp(source, destination, {
+    recursive: true,
+    force: true,
+    dereference: options.dereference ?? true,
+  })
+}
+
+export function writeBuildManifest(buildRoot, version, platform) {
+  const components = ["api", "agent", "web", "ctl"]
+  writeFileSync(path.join(buildRoot, "VERSION"), `${version}\n`)
+  writeFileSync(
+    path.join(buildRoot, "manifest.json"),
+    `${JSON.stringify(
+      {
+        name: "Vantaloom Local Runtime",
+        version,
+        platform,
+        updatedAt: new Date().toISOString(),
+        components,
+      },
+      null,
+      2
+    )}\n`
+  )
+}
+
+export function writeRuntimePackageMetadata(packageRoot, sourceRoot, platform) {
+  const version = npmPackageVersion(sourceRoot)
+  const { os: runtimeOS, cpu } = parsePlatformId(platform)
+  const name = runtimePackageName(platform)
+  writeFileSync(
+    path.join(packageRoot, "package.json"),
+    `${JSON.stringify(
+      {
+        name,
+        version,
+        private: false,
+        description: `Vantaloom local runtime for ${platform}.`,
+        type: "module",
+        os: [runtimeOS],
+        cpu: [cpu],
+        files: ["bin", "web", "cli", "manifest.json", "VERSION", "README.md"],
+        publishConfig: {
+          access: "public",
+        },
+        engines: {
+          node: ">=20",
+        },
+      },
+      null,
+      2
+    )}\n`
+  )
+  writeFileSync(
+    path.join(packageRoot, "README.md"),
+    `# ${name}\n\nPlatform runtime package for Vantaloom ${platform}. Install @vantaloom/cli instead of this package directly.\n`
+  )
+}
+
+export function npmPackageVersion(sourceRoot) {
+  const packageJSON = readJSONIfExists(path.join(sourceRoot, "packages", "cli", "package.json"))
+  return packageJSON.version ?? "0.0.0"
+}
+
+export function gitVersion(sourceRoot) {
+  const result = spawnSync("git", ["rev-parse", "--short", "HEAD"], {
+    cwd: sourceRoot,
+    encoding: "utf8",
+    windowsHide: true,
+  })
+  if (result.status === 0) {
+    return result.stdout.trim() || "dev"
+  }
+  return "dev"
+}
+
+export function buildGo(sourceRoot, buildBin, name, targetPlatform) {
+  const goEnv = targetPlatform ? platformToGoEnv(targetPlatform) : {}
+  const isWindowsTarget = targetPlatform
+    ? targetPlatform.startsWith("win32")
+    : process.platform === "win32"
+  const ext = isWindowsTarget ? ".exe" : ""
+  let ldflags = "-s -w"
+  const args = ["build"]
+  // The privileged mesh sidecar is built REPRODUCIBLY: with no embedded git VCS
+  // stamp or build id, unchanged mesh source yields byte-identical output across
+  // releases. That lets an update where the mesh hasn't changed be detected as a
+  // no-op and SKIP the privileged service re-apply — so routine updates need no
+  // UAC (Windows) / sudo (Linux/macOS) and can run fully unattended/remotely.
+  if (name === "vantaloom-mesh") {
+    args.push("-trimpath", "-buildvcs=false")
+    ldflags += " -buildid="
+  }
+  args.push(
+    "-ldflags", ldflags,
+    "-o", path.join(buildBin, `${name}${ext}`),
+    `./apps/api/cmd/${name}`
+  )
+  run("go", args, { cwd: sourceRoot, env: { ...process.env, ...goEnv } })
+}
+
+// ensureInPath adds the Vantaloom install directory to the user's shell PATH
+// on macOS and Linux, so `vantaloom` can be run directly after install.
+// On Windows this is not needed (vantaloom.cmd is run by full path or added via installer).
+export function ensureInPath(prefix) {
+  if (process.platform === "win32") return
+
+  // Check if already in PATH
+  const pathDirs = (process.env.PATH || "").split(":")
+  if (pathDirs.includes(prefix)) return
+
+  // Determine shell profile file
+  const home = os.homedir()
+  const shell = process.env.SHELL || ""
+  let profilePath
+  if (shell.endsWith("/zsh") || existsSync(path.join(home, ".zshrc"))) {
+    profilePath = path.join(home, ".zshrc")
+  } else if (shell.endsWith("/bash")) {
+    // On macOS, bash uses .bash_profile; on Linux, .bashrc
+    profilePath = process.platform === "darwin"
+      ? path.join(home, ".bash_profile")
+      : path.join(home, ".bashrc")
+  } else if (existsSync(path.join(home, ".profile"))) {
+    profilePath = path.join(home, ".profile")
+  } else {
+    profilePath = path.join(home, ".profile")
+  }
+
+  // Use $HOME-relative path for portability
+  const homeRelative = prefix.startsWith(home)
+    ? `$HOME${prefix.slice(home.length)}`
+    : prefix
+  const exportLine = `export PATH="${homeRelative}:$PATH"`
+  const marker = "# vantaloom"
+
+  // Check if already added to profile
+  try {
+    if (existsSync(profilePath)) {
+      const content = readFileSync(profilePath, "utf8")
+      if (content.includes("vantaloom") && content.includes("PATH")) return
+    }
+  } catch {}
+
+  // Append to profile
+  try {
+    const entry = `\n${marker}\n${exportLine}\n`
+    appendFileSync(profilePath, entry)
+    console.log(`PATH: added ${prefix} to ${profilePath}`)
+    console.log(`  run: source ${profilePath}  (or open a new terminal)`)
+  } catch (error) {
+    console.log(`PATH: could not update ${profilePath}: ${error.message}`)
+    console.log(`  add manually: ${exportLine}`)
+  }
+}