@highstate/cli 0.20.0 → 0.26.0

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-KA6ZC6BV.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-2s546hay.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": 3267890704,
-    "./dist/main.js": 610943987
+    "./dist/commands/index.js": 4100963334,
+    "./dist/main.js": 527856276
   }
 }

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-KA6ZC6BV.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-2s546hay.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.20.0",
+  "version": "0.26.0",
   "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.25.0",
+    "@highstate/contract": "0.25.0",
     "@inquirer/prompts": "^7.8.6",
     "@msgpack/msgpack": "^3.1.2",
-    "@pulumi/pulumi": "3.220.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.20.0",
-    "@highstate/contract": "0.20.0"
+    "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,
@@ -15,6 +12,22 @@ import {
   schemaTransformerPlugin,
 } from "../shared"
 
+function formatUnknownError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.stack ?? error.message
+  }
+
+  if (typeof error === "string") {
+    return error
+  }
+
+  try {
+    return JSON.stringify(error)
+  } catch {
+    return String(error)
+  }
+}
+
 export class BuildCommand extends Command {
   static paths = [["build"]]
 
@@ -23,12 +36,23 @@ 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)
 
   async execute(): Promise<void> {
+    try {
+      await this.build()
+    } catch (error) {
+      if (error instanceof Error) {
+        throw error
+      }
+
+      throw new Error(`Build failed with non-error rejection: ${formatUnknownError(error)}`)
+    }
+  }
+
+  private async build(): Promise<void> {
     const packageJson = await readPackageJSON()
 
     const highstateConfig = highstateConfigSchema.parse(packageJson.highstate ?? {})
@@ -50,36 +74,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

@@ -2,16 +2,13 @@ import { pathToFileURL } from "node:url"
 import { Command, UsageError } from "clipanion"
 import { consola } from "consola"
 import { colorize } from "consola/utils"
-import { getPort } from "get-port-please"
+import { checkPort, 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"
+
+let shuttingDown = false
 
 export class DesignerCommand extends Command {
   static paths = [["designer"]]
@@ -38,32 +35,32 @@ 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()
 
     const oldConsoleLog = console.log
 
-    const port = await getPort({ port: 3000 })
-    const eventsPort = await getPort({ port: 3001 })
+    const host = "127.0.0.1"
+    const configuredPort = process.env.HIGHSTATE_DESIGNER_PORT
+    const port = configuredPort === undefined ? 7283 : Number(configuredPort)
+    if (!/^\d+$/.test(configuredPort ?? port.toString()) || port < 1 || port > 65535) {
+      throw new UsageError(`HIGHSTATE_DESIGNER_PORT must be an integer between "1" and "65535"`)
+    }
+
+    if (configuredPort !== undefined) {
+      logger.warn(
+        `using custom designer port "%s"; changing the port changes the WebAuthn origin and may require registering security keys again`,
+        port,
+      )
+    }
+
+    const availablePort = await checkPort(port, host)
+    if (!availablePort) {
+      throw new UsageError(`Port "${port}" is already in use`)
+    }
+
+    const eventsPort = await getPort({ random: true, host })
 
     const designerPackageJsonPath = importMetaResolve(
       "@highstate/designer/package.json",
@@ -72,22 +69,30 @@ export class DesignerCommand extends Command {
     const designerPackageJson = await readPackageJSON(designerPackageJsonPath)
 
     process.env.NITRO_PORT = port.toString()
-    process.env.NITRO_HOST = "0.0.0.0"
+    process.env.NITRO_HOST = host
+    process.env.NITRO_BUN_IDLE_TIMEOUT ??= "255"
     process.env.NUXT_PUBLIC_VERSION = designerPackageJson.version
     process.env.NUXT_PUBLIC_EVENTS_PORT = eventsPort.toString()
 
-    await new Promise<void>(resolve => {
-      console.log = (message: string) => {
-        if (message.startsWith("Listening on")) {
-          resolve()
+    try {
+      await new Promise<void>((resolve, reject) => {
+        console.log = (message: string) => {
+          if (message.startsWith("Listening on")) {
+            if (!message.includes(`http://${host}:${port}`)) {
+              reject(new Error(`Designer started on an unexpected endpoint: ${message}`))
+              return
+            }
+
+            resolve()
+          }
         }
-      }
-
-      const serverPath = importMetaResolve("@highstate/designer/server", packageJsonUrl)
-      void import(serverPath)
-    })
 
-    console.log = oldConsoleLog
+        const serverPath = importMetaResolve("@highstate/designer/server", packageJsonUrl)
+        void import(serverPath).catch(reject)
+      })
+    } finally {
+      console.log = oldConsoleLog
+    }
 
     consola.log(
       [
@@ -95,12 +100,17 @@ export class DesignerCommand extends Command {
         colorize("bold", colorize("cyanBright", "Highstate Designer")),
         "\n  ",
         colorize("greenBright", "➜ Local:  "),
-        colorize("underline", colorize("cyanBright", `http://localhost:${port}`)),
+        colorize("underline", colorize("cyanBright", `http://highstate.localhost:${port}`)),
         "\n",
       ].join(""),
     )
 
-    process.on("SIGINT", () => {
+    process.once("SIGINT", () => {
+      if (shuttingDown) {
+        return
+      }
+      shuttingDown = true
+
       process.stdout.write("\r")
       consola.info("shutting down highstate designer...")
 

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) {