@highstate/cli 0.19.1 → 0.21.1

package/dist/{library-loader-PZWYMBAE.js → chunk-sxh2gdkm.js}

@@ -1,9 +1,17 @@
-import { int32ToBytes } from './chunk-CMECLVT7.js';
-import console from 'node:console';
-import { Crc32, crc32 } from '@aws-crypto/crc32';
-import { isComponent, isEntity, isUnitModel } from '@highstate/contract';
-import { encode } from '@msgpack/msgpack';
+// @bun
+import {
+  int32ToBytes
+} from "./chunk-vcev74he.js";
 
+// src/shared/library-loader.ts
+import console from "console";
+import { Crc32, crc32 } from "@aws-crypto/crc32";
+import {
+  isComponent,
+  isEntity,
+  isUnitModel
+} from "@highstate/contract";
+import { encode } from "@msgpack/msgpack";
 async function loadLibrary(logger, modulePaths) {
   const modules = {};
   for (const modulePath of modulePaths) {
@@ -19,13 +27,10 @@ async function loadLibrary(logger, modulePaths) {
   const components = {};
   const entities = {};
   await _loadLibrary(modules, components, entities);
-  logger.info(
-    {
-      componentCount: Object.keys(components).length,
-      entityCount: Object.keys(entities).length
-    },
-    "library loaded"
-  );
+  logger.info({
+    componentCount: Object.keys(components).length,
+    entityCount: Object.keys(entities).length
+  }, "library loaded");
   logger.trace({ components, entities }, "library content");
   return { components, entities };
 }
@@ -63,7 +68,7 @@ async function _loadLibrary(value, components, entities) {
   }
 }
 async function calculateComponentDefinitionHash(component, entityHashes) {
-  const result = new Crc32();
+  const result = new Crc32;
   result.update(encode(component.model));
   if (!isUnitModel(component.model)) {
     const serializedCreate = { text: "TODO: investigate why serializeFunction hangs" };
@@ -77,7 +82,6 @@ async function calculateComponentDefinitionHash(component, entityHashes) {
 function calculateEntityDefinitionHash(entity) {
   return crc32(encode(entity.model));
 }
-
-export { loadLibrary };
-//# sourceMappingURL=library-loader-PZWYMBAE.js.map
-//# sourceMappingURL=library-loader-PZWYMBAE.js.map
+export {
+  loadLibrary
+};

package/dist/{chunk-CMECLVT7.js → chunk-vcev74he.js}

@@ -1,3 +1,6 @@
+// @bun
+var __require = import.meta.require;
+
 // src/shared/utils.ts
 function int32ToBytes(value) {
   const buffer = new ArrayBuffer(4);
@@ -6,6 +9,4 @@ function int32ToBytes(value) {
   return new Uint8Array(buffer);
 }
 
-export { int32ToBytes };
-//# sourceMappingURL=chunk-CMECLVT7.js.map
-//# sourceMappingURL=chunk-CMECLVT7.js.map
+export { __require, int32ToBytes };

package/dist/commands/index.js

@@ -1,4 +1,30 @@
-export { BackendIdentityCommand, BackendUnlockMethodAddCommand, BackendUnlockMethodDeleteCommand, BackendUnlockMethodListCommand, BuildCommand, DesignerCommand, InitCommand, PackageCreateCommand, PackageListCommand, PackageRemoveCommand, PackageUpdateReferencesCommand, UpdateCommand } from '../chunk-6X5WTUTR.js';
-import '../chunk-CMECLVT7.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+// @bun
+import {
+  BackendIdentityCommand,
+  BackendUnlockMethodAddCommand,
+  BackendUnlockMethodDeleteCommand,
+  BackendUnlockMethodListCommand,
+  BuildCommand,
+  DesignerCommand,
+  InitCommand,
+  PackageCreateCommand,
+  PackageListCommand,
+  PackageRemoveCommand,
+  PackageUpdateReferencesCommand,
+  UpdateCommand
+} from "../chunk-n0q0pces.js";
+import"../chunk-vcev74he.js";
+export {
+  UpdateCommand,
+  PackageUpdateReferencesCommand,
+  PackageRemoveCommand,
+  PackageListCommand,
+  PackageCreateCommand,
+  InitCommand,
+  DesignerCommand,
+  BuildCommand,
+  BackendUnlockMethodListCommand,
+  BackendUnlockMethodDeleteCommand,
+  BackendUnlockMethodAddCommand,
+  BackendIdentityCommand
+};

package/dist/highstate.manifest.json

@@ -1,6 +1,6 @@
 {
   "sourceHashes": {
-    "./dist/commands/index.js": 2645287061,
-    "./dist/main.js": 457298032
+    "./dist/commands/index.js": 2077043253,
+    "./dist/main.js": 1478493098
   }
 }

package/dist/main.js

@@ -1,12 +1,26 @@
-#!/usr/bin/env node
-import { BuildCommand, DesignerCommand, InitCommand, UpdateCommand, BackendIdentityCommand, BackendUnlockMethodListCommand, BackendUnlockMethodAddCommand, BackendUnlockMethodDeleteCommand, PackageUpdateReferencesCommand, PackageListCommand, PackageCreateCommand, PackageRemoveCommand } from './chunk-6X5WTUTR.js';
-import './chunk-CMECLVT7.js';
-import { Cli, Builtins } from 'clipanion';
+#!/usr/bin/env bun
+// @bun
+import {
+  BackendIdentityCommand,
+  BackendUnlockMethodAddCommand,
+  BackendUnlockMethodDeleteCommand,
+  BackendUnlockMethodListCommand,
+  BuildCommand,
+  DesignerCommand,
+  InitCommand,
+  PackageCreateCommand,
+  PackageListCommand,
+  PackageRemoveCommand,
+  PackageUpdateReferencesCommand,
+  UpdateCommand
+} from "./chunk-n0q0pces.js";
+import"./chunk-vcev74he.js";
 
+// src/main.ts
+import { Builtins, Cli } from "clipanion";
 var cli = new Cli({
   binaryName: "highstate",
   binaryLabel: "Highstate"
-  // binaryVersion: version,
 });
 cli.register(BuildCommand);
 cli.register(DesignerCommand);
@@ -23,5 +37,3 @@ cli.register(PackageRemoveCommand);
 cli.register(Builtins.HelpCommand);
 cli.register(Builtins.VersionCommand);
 await cli.runExit(process.argv.slice(2));
-//# sourceMappingURL=main.js.map
-//# sourceMappingURL=main.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highstate/cli",
-  "version": "0.19.1",
+  "version": "0.21.1",
   "description": "The CLI for the Highstate project.",
   "type": "module",
   "files": [
@@ -25,11 +25,20 @@
       "platform"
     ]
   },
+  "scripts": {
+    "build": "bun run --bun highstate build",
+    "test": "bun run --bun vitest run",
+    "typecheck": "tsgo --noEmit --skipLibCheck",
+    "biome": "biome check --write --unsafe --error-on-warnings",
+    "biome:check": "biome check --error-on-warnings"
+  },
   "dependencies": {
     "@aws-crypto/crc32": "^5.2.0",
+    "@highstate/backend": "0.20.0",
+    "@highstate/contract": "0.20.0",
     "@inquirer/prompts": "^7.8.6",
     "@msgpack/msgpack": "^3.1.2",
-    "@pulumi/pulumi": "3.198.0",
+    "@pulumi/pulumi": "3.232.0",
     "age-encryption": "^0.2.4",
     "ajv": "^8.17.1",
     "clipanion": "^4.0.0-rc.4",
@@ -49,9 +58,7 @@
     "semver": "^7.7.3",
     "tsup": "^8.4.0",
     "yaml": "^2.8.2",
-    "zod": "^4.0.5",
-    "@highstate/backend": "0.19.1",
-    "@highstate/contract": "0.19.1"
+    "zod": "^4.0.5"
   },
   "peerDependenciesMeta": {
     "@pulumi/pulumi": {
@@ -66,17 +73,9 @@
     "@types/semver": "^7.7.1",
     "@typescript/native-preview": "^7.0.0-dev.20250920.1",
     "esbuild": "^0.25.11",
-    "highstate-cli-bootstrap": "npm:@highstate/cli",
     "vitest": "^3.2.4"
   },
   "repository": {
     "url": "https://github.com/highstate-io/highstate"
-  },
-  "scripts": {
-    "build": "highstate build",
-    "test": "vitest run",
-    "typecheck": "tsgo --noEmit --skipLibCheck",
-    "biome": "biome check --write --unsafe --error-on-warnings",
-    "biome:check": "biome check --error-on-warnings"
   }
-}
+}

package/src/commands/build.ts

@@ -1,11 +1,8 @@
-import type { Plugin } from "esbuild"
-import { writeFile } from "node:fs/promises"
+import { chmod, readFile, rm, writeFile } from "node:fs/promises"
 import { resolve } from "node:path"
 import { encode } from "@msgpack/msgpack"
 import { Command, Option } from "clipanion"
 import { readPackageJSON, resolvePackageJSON } from "pkg-types"
-import { mapValues } from "remeda"
-import { build } from "tsup"
 import {
   createBinTransformerPlugin,
   extractEntryPoints,
@@ -23,7 +20,6 @@ export class BuildCommand extends Command {
     description: "Builds the Highstate library or unit package.",
   })
 
-  watch = Option.Boolean("--watch", false)
   library = Option.Boolean("--library", false)
   silent = Option.Boolean("--silent", true)
   noSourceHash = Option.Boolean("--no-source-hash", false)
@@ -50,36 +46,56 @@ export class BuildCommand extends Command {
       return
     }
 
-    const esbuildPlugins: Plugin[] = []
+    const bunPlugins: Bun.BunPlugin[] = []
 
     const binSourceFilePaths = Object.values(entryPoints)
       .filter(value => value.isBin)
       .map(value => value.entryPoint.slice(2)) // remove "./"
 
     if (this.library) {
-      esbuildPlugins.push(schemaTransformerPlugin)
+      bunPlugins.push(schemaTransformerPlugin)
     }
 
     if (binSourceFilePaths.length > 0) {
-      esbuildPlugins.push(createBinTransformerPlugin(binSourceFilePaths))
+      bunPlugins.push(createBinTransformerPlugin(binSourceFilePaths))
     }
 
-    await build({
-      entry: mapValues(entryPoints, value => value.entryPoint),
-      outDir: "dist",
-      watch: this.watch,
-      sourcemap: true,
-      clean: true,
+    await rm("dist", { recursive: true, force: true })
+
+    const bunEntryPoints = Object.values(entryPoints).map(value => value.entryPoint)
+
+    const result = await Bun.build({
+      entrypoints: bunEntryPoints,
+      outdir: "dist",
+      root: "./src",
       format: "esm",
-      target: "es2024",
-      platform: "node",
+      target: "bun",
       external: ["@pulumi/pulumi"],
-      esbuildPlugins,
-      treeshake: true,
-      removeNodeProtocol: false,
-      silent: this.silent || ["warn", "error", "fatal"].includes(logger.level),
+      packages: "external",
+      splitting: true,
+      plugins: bunPlugins,
     })
 
+    if (!result.success) {
+      for (const log of result.logs) {
+        logger.error(log.message)
+      }
+
+      throw new Error("build failed")
+    }
+
+    const binEntryPoints = Object.values(entryPoints).filter(value => value.isBin)
+    for (const binEntryPoint of binEntryPoints) {
+      const binPath = resolve(binEntryPoint.distPath)
+      const binContent = await readFile(binPath, "utf8")
+
+      if (!binContent.startsWith("#!/usr/bin/env bun\n")) {
+        await writeFile(binPath, `#!/usr/bin/env bun\n${binContent}`, "utf8")
+      }
+
+      await chmod(binPath, 0o755)
+    }
+
     const packageJsonPath = await resolvePackageJSON()
     const upToDatePackageJson = await readPackageJSON()
 

package/src/commands/designer.ts

@@ -4,14 +4,9 @@ import { consola } from "consola"
 import { colorize } from "consola/utils"
 import { getPort } from "get-port-please"
 import { resolve as importMetaResolve } from "import-meta-resolve"
-import { addDevDependency, detectPackageManager } from "nypm"
+import { addDevDependency } from "nypm"
 import { readPackageJSON, resolvePackageJSON } from "pkg-types"
-import {
-  getBackendServices,
-  getProjectPulumiSdkVersion,
-  getPulumiCliVersion,
-  logger,
-} from "../shared"
+import { getBackendServices, logger } from "../shared"
 
 export class DesignerCommand extends Command {
   static paths = [["designer"]]
@@ -38,24 +33,6 @@ export class DesignerCommand extends Command {
       await addDevDependency(["@highstate/designer", "classic-level"])
     }
 
-    const projectRoot = process.cwd()
-    const detected = await detectPackageManager(projectRoot)
-    const packageManager = detected?.name
-
-    if (packageManager === "npm" || packageManager === "pnpm" || packageManager === "yarn") {
-      const expectedPulumiSdk = await getProjectPulumiSdkVersion(projectRoot, { packageManager })
-      const actualPulumiCli = await getPulumiCliVersion(projectRoot)
-
-      if (expectedPulumiSdk && actualPulumiCli && expectedPulumiSdk !== actualPulumiCli) {
-        logger.warn(
-          `pulumi version mismatch detected, this may cause incompatibilities\nexpected "%s" (from overrides for "@pulumi/pulumi"), got "%s" (from "pulumi version")\nrecommended: run "highstate update" or downgrade your Pulumi CLI to "%s"`,
-          expectedPulumiSdk,
-          actualPulumiCli,
-          expectedPulumiSdk,
-        )
-      }
-    }
-
     logger.info("starting highstate designer...")
 
     await getBackendServices()

package/src/commands/init.ts

@@ -1,8 +1,7 @@
-import type { PackageManagerName } from "nypm"
 import { access, mkdir, readdir } from "node:fs/promises"
 import { resolve } from "node:path"
 import { fileURLToPath } from "node:url"
-import { input, select } from "@inquirer/prompts"
+import { input } from "@inquirer/prompts"
 import { Command, Option } from "clipanion"
 import { installDependencies } from "nypm"
 import {
@@ -24,10 +23,6 @@ export class InitCommand extends Command {
     description: "The path where the project should be initialized.",
   })
 
-  packageManager = Option.String("--package-manager", {
-    description: "The package manager to use (npm, yarn, pnpm).",
-  })
-
   name = Option.String("--name", {
     description: "The project name.",
   })
@@ -41,19 +36,14 @@ export class InitCommand extends Command {
   })
 
   async execute(): Promise<void> {
-    const availablePackageManagers = await detectAvailablePackageManagers(["npm", "pnpm", "yarn"])
-    if (availablePackageManagers.length === 0) {
-      throw new Error('No supported package managers found in PATH ("npm", "pnpm", "yarn")')
+    const isBunAvailable = await isExecutableInPath("bun")
+    if (!isBunAvailable) {
+      throw new Error('Required package manager "bun" was not found in PATH')
     }
 
     const projectName = await resolveProjectName(this.name)
     const destinationPath = await resolveDestinationPath(this.pathOption, projectName)
 
-    const selectedPackageManager = await resolvePackageManager(
-      this.packageManager,
-      availablePackageManagers,
-    )
-
     const templatePath = resolveTemplatePath()
 
     const versionBundle = await resolveVersionBundle({
@@ -75,23 +65,19 @@ export class InitCommand extends Command {
       packageName: projectName,
       platformVersion: versionBundle.platformVersion,
       libraryVersion: versionBundle.stdlibVersion,
-      isPnpm: selectedPackageManager === "pnpm" ? "true" : "",
-      isYarn: selectedPackageManager === "yarn" ? "true" : "",
-      isNpm: selectedPackageManager === "npm" ? "true" : "",
     })
 
     const overrides = buildOverrides(versionBundle)
     await applyOverrides({
       projectRoot: destinationPath,
-      packageManager: selectedPackageManager,
       overrides,
     })
 
-    logger.info("installing dependencies using %s...", selectedPackageManager)
+    logger.info("installing dependencies using bun...")
 
     await installDependencies({
       cwd: destinationPath,
-      packageManager: selectedPackageManager,
+      packageManager: "bun",
       silent: false,
     })
 
@@ -137,52 +123,6 @@ async function resolveProjectName(nameOption: string | undefined): Promise<strin
   return value.trim()
 }
 
-async function resolvePackageManager(
-  packageManagerOption: string | undefined,
-  available: PackageManagerName[],
-): Promise<PackageManagerName> {
-  if (packageManagerOption) {
-    if (!isSupportedPackageManagerName(packageManagerOption)) {
-      throw new Error(`Unsupported package manager: "${packageManagerOption}"`)
-    }
-
-    const name = packageManagerOption
-    if (!available.includes(name)) {
-      throw new Error(`Package manager not found in PATH: "${name}"`)
-    }
-
-    return name
-  }
-
-  const preferredOrder: PackageManagerName[] = ["pnpm", "yarn", "npm"]
-  const defaultValue = preferredOrder.find(value => available.includes(value)) ?? available[0]
-
-  return await select({
-    message: "Package manager",
-    default: defaultValue,
-    choices: available.map(value => ({ name: value, value })),
-  })
-}
-
-function isSupportedPackageManagerName(value: string): value is PackageManagerName {
-  return value === "npm" || value === "pnpm" || value === "yarn"
-}
-
-async function detectAvailablePackageManagers(
-  candidates: PackageManagerName[],
-): Promise<PackageManagerName[]> {
-  const results: PackageManagerName[] = []
-
-  for (const candidate of candidates) {
-    const exists = await isExecutableInPath(candidate)
-    if (exists) {
-      results.push(candidate)
-    }
-  }
-
-  return results
-}
-
 async function isExecutableInPath(command: string): Promise<boolean> {
   const pathValue = process.env.PATH
   if (!pathValue) {

package/src/commands/update.ts

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises"
 import { Command, Option } from "clipanion"
-import { detectPackageManager } from "nypm"
+import { readPackageJSON, resolvePackageJSON } from "pkg-types"
 import semver from "semver"
 import {
   applyOverrides,
@@ -10,6 +10,7 @@ import {
   getProjectPlatformVersion,
   logger,
   resolveVersionBundle,
+  writeJsonFile,
 } from "../shared"
 
 export class UpdateCommand extends Command {
@@ -42,7 +43,7 @@ export class UpdateCommand extends Command {
   async execute(): Promise<void> {
     const projectRoot = process.cwd()
 
-    const packageManager = await resolveProjectPackageManager(projectRoot)
+    await assertPackageJsonExists(projectRoot)
 
     if (this.platformOnly && this.stdlibOnly) {
       throw new Error('Flags "--platform" and "--stdlib" cannot be used together')
@@ -52,9 +53,7 @@ export class UpdateCommand extends Command {
     const updateStdlib = this.stdlibOnly || !this.platformOnly
 
     if (this.stdlibOnly) {
-      const currentPlatformVersion = await getProjectPlatformVersion(projectRoot, {
-        packageManager,
-      })
+      const currentPlatformVersion = await getProjectPlatformVersion(projectRoot)
       if (!currentPlatformVersion) {
         throw new Error('Current platform version is not set in overrides for "@highstate/pulumi"')
       }
@@ -97,9 +96,12 @@ export class UpdateCommand extends Command {
     const overrides = buildOverrides(bundle)
     await applyOverrides({
       projectRoot,
-      packageManager,
       overrides,
     })
+    await syncRootPulumiDependency({
+      projectRoot,
+      pulumiVersion: bundle.pulumiVersion,
+    })
 
     logger.info(
       "updated overrides: platform=%s stdlib=%s pulumi=%s",
@@ -111,11 +113,11 @@ export class UpdateCommand extends Command {
     if (this.install) {
       const { installDependencies } = await import("nypm")
 
-      logger.info("installing dependencies using %s...", packageManager)
+      logger.info("installing dependencies using bun...")
 
       await installDependencies({
         cwd: projectRoot,
-        packageManager,
+        packageManager: "bun",
         silent: false,
       })
     }
@@ -124,29 +126,6 @@ export class UpdateCommand extends Command {
   }
 }
 
-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")
@@ -154,3 +133,19 @@ async function assertPackageJsonExists(projectRoot: string): Promise<void> {
     throw new Error(`File "package.json" not found in "${projectRoot}"`)
   }
 }
+
+async function syncRootPulumiDependency(args: {
+  projectRoot: string
+  pulumiVersion: string
+}): Promise<void> {
+  const packageJsonPath = await resolvePackageJSON(args.projectRoot)
+  const packageJson = await readPackageJSON(packageJsonPath)
+
+  await writeJsonFile(packageJsonPath, {
+    ...packageJson,
+    dependencies: {
+      ...(packageJson.dependencies ?? {}),
+      "@pulumi/pulumi": args.pulumiVersion,
+    },
+  })
+}

package/src/shared/bin-transformer.ts

@@ -1,8 +1,7 @@
-import type { Plugin } from "esbuild"
 import { readFile } from "node:fs/promises"
 import { logger } from "./logger"
 
-export function createBinTransformerPlugin(sourceFilePaths: string[]): Plugin {
+export function createBinTransformerPlugin(sourceFilePaths: string[]): Bun.BunPlugin {
   const filter = new RegExp(`(${sourceFilePaths.join("|")})$`)
 
   logger.debug("created bin transformer plugin with filter: %s", filter)
@@ -14,7 +13,7 @@ export function createBinTransformerPlugin(sourceFilePaths: string[]): Plugin {
         const content = await readFile(args.path, "utf-8")
 
         return {
-          contents: `#!/usr/bin/env node\n\n${content}`,
+          contents: `#!/usr/bin/env bun\n\n${content}`,
           loader: "ts",
         }
       })

package/src/shared/index.ts

@@ -5,7 +5,6 @@ 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"

package/src/shared/logger.ts

@@ -6,6 +6,9 @@ export const logger = pino(
   {
     name: "highstate-cli",
     level: process.env.LOG_LEVEL ?? "info",
+    serializers: {
+      error: value => serializeError(value),
+    },
   },
   createConsolaStream(),
 )
@@ -52,3 +55,56 @@ function createConsolaStream() {
 
   return stream
 }
+
+function serializeError(value: unknown, seen: WeakSet<object> = new WeakSet()): unknown {
+  if (value instanceof Error) {
+    const base: Record<string, unknown> = {
+      name: value.name,
+      message: value.message,
+      stack: value.stack,
+    }
+
+    const cause = (value as Error & { cause?: unknown }).cause
+    if (cause !== undefined) {
+      base.cause = serializeError(cause, seen)
+    }
+
+    const extraEntries = Object.entries(value)
+    if (extraEntries.length > 0) {
+      base.details = Object.fromEntries(
+        extraEntries.map(([key, entryValue]) => [key, serializeError(entryValue, seen)]),
+      )
+    }
+
+    return base
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(entry => serializeError(entry, seen))
+  }
+
+  if (value && typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]"
+    }
+
+    seen.add(value)
+
+    const entries = Object.entries(value)
+    if (entries.length === 0) {
+      return {
+        type: value.constructor?.name ?? "Object",
+        message: String(value),
+      }
+    }
+
+    return Object.fromEntries(
+      entries.map(([key, entryValue]) => [key, serializeError(entryValue, seen)]),
+    )
+  }
+
+  return {
+    type: typeof value,
+    message: String(value),
+  }
+}