@vantaloom/cli 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vantaloom/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
   "type": "module",
   "description": "Vantaloom local runtime manager.",

package/src/cli.mjs

@@ -1,5 +1,16 @@
 import { execFileSync, spawnSync } from "node:child_process"
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  readlinkSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs"
 import { cp, writeFile } from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
@@ -8,7 +19,7 @@ import { fileURLToPath } from "node:url"
 const cliRoot = path.resolve(fileURLToPath(import.meta.url), "..", "..")
 const repoCandidate = path.resolve(cliRoot, "..", "..")
 const installedConfigPath = path.join(cliRoot, "config.json")
-const defaultDistBranch = "vantaloom-dist"
+const defaultReleaseTag = "runtime-latest"
 const defaultRepo = "Timefiles404/Vantaloom-next"
 
 const runtimePackages = [
@@ -32,6 +43,8 @@ export async function main(argv) {
     case "install":
       if (options.package) {
         await installFromPackage({ ...options, update: false })
+      } else if (shouldUseDistSync(options)) {
+        await syncFromRelease(options, "install")
       } else {
         await installFromSource(options)
       }
@@ -39,8 +52,8 @@ export async function main(argv) {
     case "update":
       if (options.package) {
         await installFromPackage({ ...options, update: true })
-      } else if (shouldUseDistUpdate(options)) {
-        await updateFromDist(options)
+      } else if (shouldUseDistSync(options)) {
+        await syncFromRelease(options, "update")
       } else {
         await installFromSource({ ...options, update: true })
       }
@@ -145,7 +158,7 @@ async function buildRuntimePackage(sourceRoot, packageRoot, options) {
   buildGo(sourceRoot, buildBin, "vantaloomctl")
 
   if (options.buildWeb) {
-    run("pnpm", ["--filter", "vantaloom-app", "build"], { cwd: sourceRoot })
+    runPnpm(["--filter", "vantaloom-app", "build"], { cwd: sourceRoot })
   }
 
   await copyStandaloneWeb(sourceRoot, buildWeb)
@@ -176,7 +189,7 @@ async function applyPackage(packageRoot, prefix, options) {
     await cp(path.join(packageRoot, name), path.join(prefix, name), {
       recursive: true,
       force: true,
-      dereference: true,
+      dereference: false,
     })
   }
 
@@ -206,54 +219,71 @@ async function applyPackage(packageRoot, prefix, options) {
   return version
 }
 
-async function updateFromDist(options) {
+async function syncFromRelease(options, action) {
   const prefix = safeDirectory(options.prefix ?? defaultPrefix())
   const installedConfig = readInstalledConfig(prefix)
   const sourceRoot = installedConfig.sourceRoot
     ? tryAssertSourceRoot(installedConfig.sourceRoot)
     : tryFindSourceRoot()
   const sourceRemote = sourceRoot ? gitRemoteUrl(sourceRoot) : ""
-  const remote = options.remote ?? installedConfig.remote ?? sourceRemote
-  const repo = options.repo || installedConfig.repo || inferGitHubRepo(remote) || defaultRepo
-  const distBranch = options.distBranch ?? installedConfig.distBranch ?? defaultDistBranch
-  const cloneUrl = remote || sshRemoteFromRepo(repo)
+  const repo = options.repo || installedConfig.repo || inferGitHubRepo(options.remote ?? installedConfig.remote ?? sourceRemote) || defaultRepo
+  const releaseTag = options.releaseTag || installedConfig.releaseTag || defaultReleaseTag
   const tempRoot = mkdtempSync(path.join(os.tmpdir(), "vantaloom-update-"))
 
   try {
-    const distRoot = path.join(tempRoot, "dist")
     const extractRoot = path.join(tempRoot, "extract")
+    const archive = path.join(tempRoot, `vantaloom-${platformId()}.tar.gz`)
     mkdirSync(extractRoot, { recursive: true })
 
-    run("git", [
-      "clone",
-      "--depth",
-      "1",
-      "--branch",
-      distBranch,
-      cloneUrl,
-      distRoot,
-    ])
-
-    const archive = findPackageArchive(distRoot, platformId())
+    await downloadReleaseAsset({
+      repo,
+      releaseTag,
+      assetName: `vantaloom-${platformId()}.tar.gz`,
+      target: archive,
+      token: options.githubToken,
+    })
     run("tar", ["-xzf", archive, "-C", extractRoot])
 
     const packageRoot = findExtractedPackage(extractRoot, platformId())
     const version = await applyPackage(packageRoot, prefix, {
       noStart: options.noStart,
       sourceRoot: installedConfig.sourceRoot,
-      update: true,
+      update: action === "update",
     })
 
-    console.log(`updated Vantaloom: ${prefix}`)
+    console.log(`${action === "update" ? "updated" : "installed"} Vantaloom: ${prefix}`)
     console.log(`version: ${version}`)
-    console.log(`source: ${repo}#${distBranch}`)
+    console.log(`source: ${repo}@${releaseTag}`)
     console.log(`run: ${displayCommand(prefix)} status`)
   } finally {
     removeKnownPath(tempRoot, os.tmpdir())
   }
 }
 
-function shouldUseDistUpdate(options) {
+async function downloadReleaseAsset({ repo, releaseTag, assetName, target, token }) {
+  const url = `https://github.com/${repo}/releases/download/${releaseTag}/${assetName}`
+  const headers = {
+    "User-Agent": "vantaloom-cli",
+  }
+  const githubToken = token || process.env.VANTALOOM_GITHUB_TOKEN || process.env.GITHUB_TOKEN
+  if (githubToken) {
+    headers.Authorization = `Bearer ${githubToken}`
+  }
+
+  const response = await fetch(url, { headers })
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "")
+    const authHint = response.status === 404 || response.status === 403
+      ? " If the repository is private, set VANTALOOM_GITHUB_TOKEN to a GitHub token that can read releases."
+      : ""
+    throw new Error(`failed to download ${assetName} from ${repo}@${releaseTag}: HTTP ${response.status}.${authHint}${detail ? ` ${detail.slice(0, 200)}` : ""}`)
+  }
+
+  const buffer = Buffer.from(await response.arrayBuffer())
+  await writeFile(target, buffer)
+}
+
+function shouldUseDistSync(options) {
   return !options.local && !options.source && !options.buildWeb
 }
 
@@ -287,7 +317,7 @@ function readJSONIfExists(filePath) {
 
 function mergeRuntimeConfig(packageConfig, existingConfig, overrides) {
   const merged = { ...packageConfig }
-  for (const key of ["sourceRoot", "remote", "repo", "distBranch"]) {
+  for (const key of ["sourceRoot", "remote", "repo", "releaseTag"]) {
     if (!merged[key] && existingConfig[key]) {
       merged[key] = existingConfig[key]
     }
@@ -298,8 +328,8 @@ function mergeRuntimeConfig(packageConfig, existingConfig, overrides) {
   if (!merged.repo) {
     merged.repo = defaultRepo
   }
-  if (!merged.distBranch) {
-    merged.distBranch = defaultDistBranch
+  if (!merged.releaseTag) {
+    merged.releaseTag = defaultReleaseTag
   }
   return merged
 }
@@ -311,23 +341,10 @@ function runtimeConfigFromSource(sourceRoot) {
     ...(process.env.GITHUB_ACTIONS ? {} : { sourceRoot }),
     ...(remote ? { remote } : {}),
     repo,
-    distBranch: defaultDistBranch,
+    releaseTag: defaultReleaseTag,
   }
 }
 
-function findPackageArchive(distRoot, platform) {
-  const candidates = [
-    path.join(distRoot, "packages", `vantaloom-${platform}.tar.gz`),
-    path.join(distRoot, `vantaloom-${platform}.tar.gz`),
-  ]
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      return candidate
-    }
-  }
-  throw new Error(`missing CI package for ${platform} in ${distRoot}`)
-}
-
 function findExtractedPackage(extractRoot, platform) {
   const expected = path.join(extractRoot, `vantaloom-${platform}`)
   if (existsSync(expected)) {
@@ -384,10 +401,6 @@ function inferGitHubRepo(remote) {
   return sshMatch?.[1] ?? ""
 }
 
-function sshRemoteFromRepo(repo) {
-  return `git@github.com:${repo}.git`
-}
-
 async function copyStandaloneWeb(sourceRoot, buildWeb) {
   const standalone = path.join(sourceRoot, "apps", "vantaloom", ".next", "standalone")
   const staticSource = path.join(sourceRoot, "apps", "vantaloom", ".next", "static")
@@ -399,7 +412,11 @@ async function copyStandaloneWeb(sourceRoot, buildWeb) {
   }
 
   removeKnownPath(buildWeb, path.dirname(buildWeb))
-  await copyDir(standalone, buildWeb)
+  const preserveStandaloneLinks = process.platform !== "win32"
+  await copyDir(standalone, buildWeb, { dereference: !preserveStandaloneLinks })
+  if (preserveStandaloneLinks) {
+    await copyStandaloneHoistedTargets(sourceRoot, buildWeb)
+  }
   await copyDir(staticSource, path.join(buildWeb, "apps", "vantaloom", ".next", "static"))
   await copyDir(publicSource, path.join(buildWeb, "apps", "vantaloom", "public"))
 
@@ -486,13 +503,72 @@ async function copyPnpmRuntimePackage(sourceRoot, packageName, destinationNodeMo
   await copyDir(source, path.join(destinationNodeModules, ...packageName.split("/")))
 }
 
-async function copyDir(source, destination) {
+async function copyStandaloneHoistedTargets(sourceRoot, buildWeb) {
+  const sourceHoisted = path.join(sourceRoot, "node_modules", ".pnpm", "node_modules")
+  const buildHoisted = path.join(buildWeb, "node_modules", ".pnpm", "node_modules")
+  const packageNames = findHoistedSymlinkPackages(path.join(buildWeb, "node_modules"))
+
+  for (const packageName of packageNames) {
+    const source = path.join(sourceHoisted, ...packageName.split("/"))
+    if (existsSync(source)) {
+      await copyDir(source, path.join(buildHoisted, ...packageName.split("/")))
+    }
+  }
+}
+
+function findHoistedSymlinkPackages(nodeModules) {
+  const packages = new Set()
+  if (!existsSync(nodeModules)) {
+    return packages
+  }
+
+  for (const entry of readdirSync(nodeModules, { withFileTypes: true })) {
+    if (entry.name === ".pnpm" || entry.name.startsWith(".")) {
+      continue
+    }
+
+    const entryPath = path.join(nodeModules, entry.name)
+    if (entry.name.startsWith("@") && entry.isDirectory()) {
+      for (const scopedEntry of readdirSync(entryPath, { withFileTypes: true })) {
+        addHoistedSymlinkPackage(packages, path.join(entryPath, scopedEntry.name), `${entry.name}/${scopedEntry.name}`)
+      }
+      continue
+    }
+
+    addHoistedSymlinkPackage(packages, entryPath, entry.name)
+  }
+
+  return packages
+}
+
+function addHoistedSymlinkPackage(packages, packagePath, packageName) {
+  let stat
+  try {
+    stat = lstatSync(packagePath)
+  } catch {
+    return
+  }
+  if (!stat.isSymbolicLink()) {
+    return
+  }
+
+  const target = readlinkSync(packagePath).replaceAll("\\", "/")
+  if (target.includes(".pnpm/node_modules/")) {
+    packages.add(packageName)
+  }
+}
+
+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: true })
+  await cp(source, destination, {
+    recursive: true,
+    force: true,
+    dereference: options.dereference ?? true,
+  })
 }
 
 function writeBuildManifest(buildRoot, version, platform) {
@@ -563,7 +639,8 @@ function parseOptions(args) {
       case "output":
       case "repo":
       case "remote":
-      case "dist-branch":
+      case "release-tag":
+      case "github-token":
         options[toCamel(key)] = inlineValue ?? args[++index]
         if (!options[toCamel(key)]) {
           throw new Error(`missing value for --${key}`)
@@ -621,6 +698,14 @@ function run(command, args, options = {}) {
   }
 }
 
+function runPnpm(args, options = {}) {
+  if (process.platform === "win32") {
+    run("cmd.exe", ["/d", "/s", "/c", "pnpm", ...args], options)
+    return
+  }
+  run("pnpm", args, options)
+}
+
 function binaryName(name) {
   return process.platform === "win32" ? `${name}.exe` : name
 }
@@ -662,8 +747,9 @@ function printHelp() {
   console.log(`Vantaloom CLI
 
 Usage:
-  vantaloom install  [--prefix <dir>] [--source <repo>] [--build-web] [--package <dir>] [--no-start]
-  vantaloom update   [--prefix <dir>] [--repo <owner/name>] [--remote <git-url>] [--dist-branch <branch>] [--no-start]
+  vantaloom install  [--prefix <dir>] [--repo <owner/name>] [--release-tag <tag>] [--github-token <token>] [--package <dir>] [--no-start]
+  vantaloom install  --local [--prefix <dir>] [--source <repo>] [--build-web] [--no-start]
+  vantaloom update   [--prefix <dir>] [--repo <owner/name>] [--release-tag <tag>] [--github-token <token>] [--no-start]
   vantaloom update   --local [--prefix <dir>] [--source <repo>] [--build-web] [--no-start]
   vantaloom package  [--source <repo>] [--output <dir>] [--build-web] [--archive]
   vantaloom start    [--prefix <dir>] [--component all|api|agent|web]