@highstate/cli 0.15.0 → 0.16.0

package/src/commands/update.ts

@@ -0,0 +1,156 @@
+import { readFile } from "node:fs/promises"
+import { Command, Option } from "clipanion"
+import { detectPackageManager } from "nypm"
+import semver from "semver"
+import {
+  applyOverrides,
+  buildOverrides,
+  fetchManifest,
+  getDependencyRange,
+  getProjectPlatformVersion,
+  logger,
+  resolveVersionBundle,
+} from "../shared"
+
+export class UpdateCommand extends Command {
+  static paths = [["update"]]
+
+  static usage = Command.Usage({
+    description: "Updates version overrides in an existing Highstate project.",
+  })
+
+  platformVersion = Option.String("--platform-version", {
+    description: "The Highstate platform version to set.",
+  })
+
+  stdlibVersion = Option.String("--stdlib-version", {
+    description: "The Highstate standard library version to set.",
+  })
+
+  platformOnly = Option.Boolean("--platform", false, {
+    description: "Update only platform versions.",
+  })
+
+  stdlibOnly = Option.Boolean("--stdlib", false, {
+    description: "Update only standard library versions.",
+  })
+
+  install = Option.Boolean("--install", true, {
+    description: "Install dependencies after updating overrides.",
+  })
+
+  async execute(): Promise<void> {
+    const projectRoot = process.cwd()
+
+    const packageManager = await resolveProjectPackageManager(projectRoot)
+
+    if (this.platformOnly && this.stdlibOnly) {
+      throw new Error('Flags "--platform" and "--stdlib" cannot be used together')
+    }
+
+    const updatePlatform = this.platformOnly || !this.stdlibOnly
+    const updateStdlib = this.stdlibOnly || !this.platformOnly
+
+    if (this.stdlibOnly) {
+      const currentPlatformVersion = await getProjectPlatformVersion(projectRoot, {
+        packageManager,
+      })
+      if (!currentPlatformVersion) {
+        throw new Error('Current platform version is not set in overrides for "@highstate/pulumi"')
+      }
+
+      const targetStdlibVersion = (this.stdlibVersion ?? "").trim()
+      if (targetStdlibVersion.length === 0) {
+        throw new Error('Flag "--stdlib-version" must be provided when using "--stdlib"')
+      }
+
+      const stdlibManifest = await fetchManifest("@highstate/library", targetStdlibVersion)
+      const supportedPlatformRange = getDependencyRange(stdlibManifest, "@highstate/pulumi")
+      if (!supportedPlatformRange) {
+        throw new Error(
+          `Unable to infer "@highstate/pulumi" version from "@highstate/library@${targetStdlibVersion}"`,
+        )
+      }
+
+      const validPlatform = semver.valid(currentPlatformVersion)
+      if (!validPlatform) {
+        throw new Error(
+          `Current platform version is not a valid semver "${currentPlatformVersion}"`,
+        )
+      }
+
+      const ok = semver.satisfies(validPlatform, supportedPlatformRange, {
+        includePrerelease: true,
+      })
+      if (!ok) {
+        throw new Error(
+          `Current platform version "${currentPlatformVersion}" does not satisfy requirement "${supportedPlatformRange}"`,
+        )
+      }
+    }
+
+    const bundle = await resolveVersionBundle({
+      platformVersion: updatePlatform ? this.platformVersion : undefined,
+      stdlibVersion: updateStdlib ? this.stdlibVersion : undefined,
+    })
+
+    const overrides = buildOverrides(bundle)
+    await applyOverrides({
+      projectRoot,
+      packageManager,
+      overrides,
+    })
+
+    logger.info(
+      "updated overrides: platform=%s stdlib=%s pulumi=%s",
+      bundle.platformVersion,
+      bundle.stdlibVersion,
+      bundle.pulumiVersion,
+    )
+
+    if (this.install) {
+      const { installDependencies } = await import("nypm")
+
+      logger.info("installing dependencies using %s...", packageManager)
+
+      await installDependencies({
+        cwd: projectRoot,
+        packageManager,
+        silent: false,
+      })
+    }
+
+    logger.info("update completed successfully")
+  }
+}
+
+async function resolveProjectPackageManager(projectRoot: string) {
+  const detected = await detectPackageManager(projectRoot)
+  if (!detected?.name) {
+    throw new Error("Unable to detect package manager for this project")
+  }
+
+  if (detected.name === "bun") {
+    throw new Error('Package manager "bun" is not supported')
+  }
+
+  if (detected.name === "deno") {
+    throw new Error('Package manager "deno" is not supported')
+  }
+
+  if (detected.name !== "npm" && detected.name !== "pnpm" && detected.name !== "yarn") {
+    throw new Error(`Unsupported package manager: "${detected.name}"`)
+  }
+
+  await assertPackageJsonExists(projectRoot)
+
+  return detected.name
+}
+
+async function assertPackageJsonExists(projectRoot: string): Promise<void> {
+  try {
+    await readFile(`${projectRoot}/package.json`, "utf8")
+  } catch {
+    throw new Error(`File "package.json" not found in "${projectRoot}"`)
+  }
+}

package/src/main.ts

@@ -1,33 +1,36 @@
 import { Builtins, Cli } from "clipanion"
-import { version } from "../package.json"
-import { BackendIdentityCommand } from "./commands/backend/identity"
-import { BackendUnlockMethodAddCommand } from "./commands/backend/unlock-method/add"
-import { BackendUnlockMethodDeleteCommand } from "./commands/backend/unlock-method/delete"
-import { BackendUnlockMethodListCommand } from "./commands/backend/unlock-method/list"
-import { BuildCommand } from "./commands/build"
-import { DesignerCommand } from "./commands/designer"
-import { InitCommand } from "./commands/init"
 import {
-  CreateCommand as PackageCreateCommand,
-  ListCommand as PackageListCommand,
-  RemoveCommand as PackageRemoveCommand,
-  UpdateReferencesCommand,
-} from "./commands/package"
+  BackendIdentityCommand,
+  BackendUnlockMethodAddCommand,
+  BackendUnlockMethodDeleteCommand,
+  BackendUnlockMethodListCommand,
+  BuildCommand,
+  DesignerCommand,
+  InitCommand,
+  PackageCreateCommand,
+  PackageListCommand,
+  PackageRemoveCommand,
+  PackageUpdateReferencesCommand,
+  UpdateCommand,
+} from "./commands"
+
+// const { version } = await import("@highstate/cli/package.json")
 
 const cli = new Cli({
   binaryName: "highstate",
   binaryLabel: "Highstate",
-  binaryVersion: version,
+  // binaryVersion: version,
 })
 
 cli.register(BuildCommand)
 cli.register(DesignerCommand)
 cli.register(InitCommand)
+cli.register(UpdateCommand)
 cli.register(BackendIdentityCommand)
 cli.register(BackendUnlockMethodListCommand)
 cli.register(BackendUnlockMethodAddCommand)
 cli.register(BackendUnlockMethodDeleteCommand)
-cli.register(UpdateReferencesCommand)
+cli.register(PackageUpdateReferencesCommand)
 cli.register(PackageListCommand)
 cli.register(PackageCreateCommand)
 cli.register(PackageRemoveCommand)

package/src/shared/entry-points.ts

@@ -55,18 +55,25 @@ export function extractEntryPoints(packageJson: PackageJson): Record<string, Ent
         throw new Error(`Export "${key}" must be a string or an object in package.json`)
       }
 
-      if (!distPath.startsWith("./dist/")) {
+      const isJsonExport = distPath.endsWith(".json")
+      const isJsExport = distPath.endsWith(".js")
+
+      if (!isJsonExport && !isJsExport) {
         throw new Error(
-          `The default value of export "${key}" must start with "./dist/" in package.json, got "${distPath}"`,
+          `The default value of export "${key}" must end with ".js" or ".json" in package.json, got "${distPath}"`,
         )
       }
 
-      if (!distPath.endsWith(".js")) {
+      if (isJsExport && !distPath.startsWith("./dist/")) {
         throw new Error(
-          `The default value of export "${key}" must end with ".js" in package.json, got "${distPath}"`,
+          `The default value of export "${key}" must start with "./dist/" when exporting ".js" in package.json, got "${distPath}"`,
         )
       }
 
+      if (isJsonExport) {
+        continue
+      }
+
       const targetName = distPath.slice(7).slice(0, -3)
 
       result[targetName] = {

package/src/shared/index.ts

@@ -2,8 +2,16 @@ export * from "./bin-transformer"
 export * from "./entry-points"
 export * from "./generator"
 export * from "./logger"
+export * from "./npm-registry"
+export * from "./overrides"
+export * from "./package-json"
+export * from "./pnpm-workspace"
+export * from "./project-versions"
+export * from "./pulumi-cli"
 export * from "./schema-transformer"
 export * from "./schemas"
 export * from "./services"
 export * from "./source-hash-calculator"
+export * from "./version-bundle"
+export * from "./version-sets"
 export * from "./workspace"

package/src/shared/npm-registry.ts

@@ -0,0 +1,67 @@
+export type NpmRegistryManifest = {
+  name?: string
+  version?: string
+  peerDependencies?: Record<string, string>
+  dependencies?: Record<string, string>
+  optionalDependencies?: Record<string, string>
+}
+
+export type NpmRegistryPackument = {
+  "dist-tags"?: {
+    latest?: string
+  }
+  versions?: Record<string, NpmRegistryManifest>
+}
+
+export async function fetchNpmPackument(packageName: string): Promise<NpmRegistryPackument> {
+  const encoded = encodeURIComponent(packageName)
+  const url = `https://registry.npmjs.org/${encoded}`
+
+  const response = await fetch(url)
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch package "${packageName}" from NPM registry (HTTP ${response.status})`,
+    )
+  }
+
+  return (await response.json()) as NpmRegistryPackument
+}
+
+export async function fetchLatestVersion(packageName: string): Promise<string> {
+  const packument = await fetchNpmPackument(packageName)
+  const latest = packument["dist-tags"]?.latest
+  if (!latest) {
+    throw new Error(
+      `NPM registry response for package "${packageName}" does not include "dist-tags.latest"`,
+    )
+  }
+
+  return latest
+}
+
+export async function fetchManifest(
+  packageName: string,
+  version: string,
+): Promise<NpmRegistryManifest> {
+  const packument = await fetchNpmPackument(packageName)
+  const manifest = packument.versions?.[version]
+  if (!manifest) {
+    throw new Error(
+      `NPM registry response for package "${packageName}" does not include version "${version}"`,
+    )
+  }
+
+  return manifest
+}
+
+export function getDependencyRange(
+  manifest: NpmRegistryManifest,
+  dependencyName: string,
+): string | null {
+  return (
+    manifest.peerDependencies?.[dependencyName] ??
+    manifest.dependencies?.[dependencyName] ??
+    manifest.optionalDependencies?.[dependencyName] ??
+    null
+  )
+}

package/src/shared/overrides.ts

@@ -0,0 +1,73 @@
+import type { PackageManagerName } from "nypm"
+import type { VersionBundle } from "./version-bundle"
+import { access } from "node:fs/promises"
+import { readPackageJSON, resolvePackageJSON } from "pkg-types"
+import { writeJsonFile } from "./package-json"
+import { readPnpmWorkspace, resolvePnpmWorkspacePath, writePnpmWorkspace } from "./pnpm-workspace"
+import { PLATFORM_PACKAGES, PULUMI_PACKAGES, STDLIB_PACKAGES } from "./version-sets"
+
+export type Overrides = Record<string, string>
+
+export function buildOverrides(bundle: VersionBundle): Overrides {
+  const platform = Object.fromEntries(PLATFORM_PACKAGES.map(name => [name, bundle.platformVersion]))
+  const stdlib = Object.fromEntries(STDLIB_PACKAGES.map(name => [name, bundle.stdlibVersion]))
+  const pulumi = Object.fromEntries(PULUMI_PACKAGES.map(name => [name, bundle.pulumiVersion]))
+
+  const merged: Overrides = {
+    ...platform,
+    ...stdlib,
+    ...pulumi,
+  }
+
+  return merged
+}
+
+export type ApplyOverridesArgs = {
+  packageManager: PackageManagerName
+  overrides: Overrides
+  projectRoot: string
+}
+
+export async function applyOverrides(args: ApplyOverridesArgs): Promise<void> {
+  const { packageManager, overrides, projectRoot } = args
+
+  if (packageManager === "pnpm") {
+    const pnpmWorkspacePath = resolvePnpmWorkspacePath(projectRoot)
+
+    try {
+      await access(pnpmWorkspacePath)
+    } catch {
+      throw new Error(`PNPM workspace file is missing: "${pnpmWorkspacePath}"`)
+    }
+
+    const workspace = await readPnpmWorkspace(pnpmWorkspacePath)
+    const nextWorkspace = {
+      ...workspace,
+      overrides,
+    }
+
+    await writePnpmWorkspace(pnpmWorkspacePath, nextWorkspace)
+    return
+  }
+
+  const packageJsonPath = await resolvePackageJSON(projectRoot)
+  const packageJson = await readPackageJSON(projectRoot)
+
+  if (packageManager === "npm") {
+    await writeJsonFile(packageJsonPath, {
+      ...packageJson,
+      overrides,
+    })
+    return
+  }
+
+  if (packageManager === "yarn") {
+    await writeJsonFile(packageJsonPath, {
+      ...packageJson,
+      resolutions: overrides,
+    })
+    return
+  }
+
+  await writeJsonFile(packageJsonPath, packageJson)
+}

package/src/shared/package-json.ts

@@ -0,0 +1,6 @@
+import { writeFile } from "node:fs/promises"
+
+export async function writeJsonFile(filePath: string, value: unknown): Promise<void> {
+  const contents = `${JSON.stringify(value, null, 2)}\n`
+  await writeFile(filePath, contents, "utf8")
+}

package/src/shared/pnpm-workspace.ts

@@ -0,0 +1,32 @@
+import { readFile, writeFile } from "node:fs/promises"
+import { resolve } from "node:path"
+import { parse, stringify } from "yaml"
+
+export type PnpmWorkspace = {
+  packages?: string[]
+  overrides?: Record<string, string>
+}
+
+export function resolvePnpmWorkspacePath(projectRoot: string): string {
+  return resolve(projectRoot, "pnpm-workspace.yaml")
+}
+
+export async function readPnpmWorkspace(filePath: string): Promise<PnpmWorkspace> {
+  const raw = await readFile(filePath, "utf8")
+  const parsed = parse(raw)
+
+  if (typeof parsed !== "object" || parsed === null) {
+    return {}
+  }
+
+  return parsed as PnpmWorkspace
+}
+
+export async function writePnpmWorkspace(
+  filePath: string,
+  workspace: PnpmWorkspace,
+): Promise<void> {
+  const raw = stringify(workspace)
+
+  await writeFile(filePath, raw, "utf8")
+}

package/src/shared/project-versions.ts

@@ -0,0 +1,54 @@
+import type { PackageManagerName } from "nypm"
+import type { PackageJson } from "pkg-types"
+import { readFile } from "node:fs/promises"
+import { resolvePackageJSON } from "pkg-types"
+import { readPnpmWorkspace, resolvePnpmWorkspacePath } from "./pnpm-workspace"
+
+export async function getProjectOverrideVersion(
+  projectRoot: string,
+  args: { packageManager: PackageManagerName; packageName: string },
+): Promise<string | null> {
+  const { packageManager, packageName } = args
+
+  if (packageManager === "pnpm") {
+    const path = resolvePnpmWorkspacePath(projectRoot)
+    const workspace = await readPnpmWorkspace(path)
+    return workspace.overrides?.[packageName] ?? null
+  }
+
+  const packageJsonPath = await resolvePackageJSON(projectRoot)
+  const rawPackageJson = await readFile(packageJsonPath, "utf8")
+  const packageJson = JSON.parse(rawPackageJson) as PackageJson
+
+  if (packageManager === "npm") {
+    const overrides = packageJson.overrides as Record<string, string> | undefined
+    return overrides?.[packageName] ?? null
+  }
+
+  if (packageManager === "yarn") {
+    const resolutions = packageJson.resolutions as Record<string, string> | undefined
+    return resolutions?.[packageName] ?? null
+  }
+
+  return null
+}
+
+export async function getProjectPlatformVersion(
+  projectRoot: string,
+  args: { packageManager: PackageManagerName },
+): Promise<string | null> {
+  return await getProjectOverrideVersion(projectRoot, {
+    packageManager: args.packageManager,
+    packageName: "@highstate/pulumi",
+  })
+}
+
+export async function getProjectPulumiSdkVersion(
+  projectRoot: string,
+  args: { packageManager: PackageManagerName },
+): Promise<string | null> {
+  return await getProjectOverrideVersion(projectRoot, {
+    packageManager: args.packageManager,
+    packageName: "@pulumi/pulumi",
+  })
+}

package/src/shared/pulumi-cli.ts

@@ -0,0 +1,21 @@
+import { execFile } from "node:child_process"
+import { promisify } from "node:util"
+
+const execFileAsync = promisify(execFile)
+
+export async function getPulumiCliVersion(cwd: string): Promise<string | null> {
+  try {
+    const { stdout } = await execFileAsync("pulumi", ["version"], {
+      cwd,
+    })
+
+    const raw = stdout.trim()
+    if (raw.length === 0) {
+      return null
+    }
+
+    return raw.startsWith("v") ? raw.slice(1) : raw
+  } catch {
+    return null
+  }
+}

package/src/shared/version-bundle.ts

@@ -0,0 +1,51 @@
+import { fetchLatestVersion, fetchManifest, getDependencyRange } from "./npm-registry"
+
+export type VersionBundle = {
+  platformVersion: string
+  stdlibVersion: string
+  pulumiVersion: string
+}
+
+export type ResolveVersionBundleArgs = {
+  platformVersion?: string
+  stdlibVersion?: string
+}
+
+const platformSourcePackage = "@highstate/pulumi"
+const stdlibSourcePackage = "@highstate/library"
+
+export async function resolveVersionBundle(args: ResolveVersionBundleArgs): Promise<VersionBundle> {
+  const platformVersion = normalizeProvidedVersion(args.platformVersion, "platform")
+  const stdlibVersion = normalizeProvidedVersion(args.stdlibVersion, "stdlib")
+
+  const resolvedPlatformVersion =
+    platformVersion ?? (await fetchLatestVersion(platformSourcePackage))
+  const resolvedStdlibVersion = stdlibVersion ?? (await fetchLatestVersion(stdlibSourcePackage))
+
+  const platformManifest = await fetchManifest(platformSourcePackage, resolvedPlatformVersion)
+  const inferredPulumi = getDependencyRange(platformManifest, "@pulumi/pulumi")
+  if (!inferredPulumi) {
+    throw new Error(
+      `Unable to infer "@pulumi/pulumi" version from "${platformSourcePackage}@${resolvedPlatformVersion}"`,
+    )
+  }
+
+  return {
+    platformVersion: resolvedPlatformVersion,
+    stdlibVersion: resolvedStdlibVersion,
+    pulumiVersion: inferredPulumi,
+  }
+}
+
+function normalizeProvidedVersion(value: string | undefined, label: string): string | undefined {
+  if (value === undefined) {
+    return undefined
+  }
+
+  const trimmed = value.trim()
+  if (trimmed.length === 0) {
+    throw new Error(`Version flag "${label}" must not be empty`)
+  }
+
+  return trimmed
+}

package/src/shared/version-sets.ts

@@ -0,0 +1,36 @@
+export const PLATFORM_PACKAGES = [
+  "@highstate/api",
+  "@highstate/backend",
+  "@highstate/backend-api",
+  "@highstate/cli",
+  "@highstate/contract",
+  "@highstate/designer",
+  "@highstate/pulumi",
+  "@highstate/worker-sdk",
+]
+
+export const STDLIB_PACKAGES = [
+  "@highstate/cilium",
+  "@highstate/cloudflare",
+  "@highstate/common",
+  "@highstate/distributions",
+  "@highstate/git",
+  "@highstate/k3s",
+  "@highstate/k8s",
+  "@highstate/k8s.apps",
+  "@highstate/k8s.game-servers",
+  "@highstate/k8s.monitor-worker",
+  "@highstate/k8s.obfuscators",
+  "@highstate/library",
+  "@highstate/mullvad",
+  "@highstate/nixos",
+  "@highstate/proxmox",
+  "@highstate/restic",
+  "@highstate/sops",
+  "@highstate/talos",
+  "@highstate/timeweb",
+  "@highstate/wireguard",
+  "@highstate/yandex",
+]
+
+export const PULUMI_PACKAGES = ["@pulumi/pulumi"]

package/src/commands/package/index.ts

@@ -1,4 +0,0 @@
-export { CreateCommand } from "./create"
-export { ListCommand } from "./list"
-export { RemoveCommand } from "./remove"
-export { UpdateReferencesCommand } from "./update-references"