@highstate/cli 0.19.1 → 0.21.1

package/src/shared/overrides.ts

@@ -1,9 +1,6 @@
-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>
@@ -23,51 +20,18 @@ export function buildOverrides(bundle: VersionBundle): Overrides {
 }
 
 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 { overrides, projectRoot } = args
 
   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)
+  await writeJsonFile(packageJsonPath, {
+    ...packageJson,
+    overrides,
+  })
 }

package/src/shared/project-versions.ts

@@ -1,54 +1,29 @@
-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 },
+  args: { 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 { packageName } = args
 
   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
+  const overrides = packageJson.overrides as Record<string, string> | undefined
+  return overrides?.[packageName] ?? null
 }
 
-export async function getProjectPlatformVersion(
-  projectRoot: string,
-  args: { packageManager: PackageManagerName },
-): Promise<string | null> {
+export async function getProjectPlatformVersion(projectRoot: string): 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> {
+export async function getProjectPulumiSdkVersion(projectRoot: string): Promise<string | null> {
   return await getProjectOverrideVersion(projectRoot, {
-    packageManager: args.packageManager,
     packageName: "@pulumi/pulumi",
   })
 }

package/src/shared/pulumi-cli.ts

@@ -3,9 +3,12 @@ import { promisify } from "node:util"
 
 const execFileAsync = promisify(execFile)
 
-export async function getPulumiCliVersion(cwd: string): Promise<string | null> {
+export async function getPulumiCliVersion(
+  cwd: string,
+  commandPath = "pulumi",
+): Promise<string | null> {
   try {
-    const { stdout } = await execFileAsync("pulumi", ["version"], {
+    const { stdout } = await execFileAsync(commandPath, ["version"], {
       cwd,
     })
 

package/src/shared/schema-transformer.spec.ts

@@ -696,4 +696,19 @@ export const testUnit = defineUnit({
     const metaMatches = (result.match(/meta\s*:\s*\{/g) || []).length
     expect(metaMatches).toBe(1)
   })
+
+  it("should not transform runtime call input objects", async () => {
+    const input = `
+const { addressSpace } = network.addressSpace({
+  name: "demo",
+  inputs: {
+    excludedL4Endpoints: l4Endpoints,
+  },
+})`
+
+    const result = await applySchemaTransformations(input)
+
+    expect(result).toContain("excludedL4Endpoints: l4Endpoints")
+    expect(result).not.toContain("$addInputDescription(l4Endpoints")
+  })
 })

package/src/shared/schema-transformer.ts

@@ -1,4 +1,3 @@
-import type { Plugin } from "esbuild"
 import { readFile } from "node:fs/promises"
 import MagicString from "magic-string"
 import {
@@ -10,7 +9,7 @@ import {
 } from "oxc-parser"
 import { type Node, walk } from "oxc-walker"
 
-export const schemaTransformerPlugin: Plugin = {
+export const schemaTransformerPlugin: Bun.BunPlugin = {
   name: "schema-transformer",
   setup(build) {
     build.onLoad({ filter: /src\/.*\.ts$/ }, async args => {
@@ -439,6 +438,10 @@ function getHelperFunctionForProperty(
     containerParent.value === objectExpression &&
     containerParent.key?.type === "Identifier"
   ) {
+    if (!isDefinitionLikeContext(parentStack)) {
+      return null
+    }
+
     const keyName = containerParent.key.name
     if (keyName === "inputs" || keyName === "outputs") {
       return "$addInputDescription"
@@ -468,6 +471,32 @@ function getHelperFunctionForProperty(
   return null
 }
 
+function isDefinitionLikeContext(parentStack: Node[]): boolean {
+  for (let i = parentStack.length - 1; i >= 0; i--) {
+    const node = parentStack[i]
+    if (node.type !== "CallExpression") {
+      continue
+    }
+
+    if (node.callee.type !== "Identifier") {
+      return false
+    }
+
+    return [
+      "defineComponent",
+      "defineUnit",
+      "defineEntity",
+      "$inputs",
+      "$outputs",
+      "$args",
+      "$secrets",
+    ].includes(node.callee.name)
+  }
+
+  // top-level literal specs (without define* wrappers) are still valid transform targets
+  return true
+}
+
 function isZodObjectCall(memberExpression: Node): boolean {
   if (
     memberExpression.type !== "MemberExpression" ||

package/src/shared/source-hash-calculator.ts

@@ -1,6 +1,7 @@
 import type { Logger } from "pino"
 import { readFile, writeFile } from "node:fs/promises"
-import { dirname, relative, resolve } from "node:path"
+import { builtinModules } from "node:module"
+import { dirname, isAbsolute, relative, resolve } from "node:path"
 import { fileURLToPath, pathToFileURL } from "node:url"
 import { crc32 } from "@aws-crypto/crc32"
 import { resolve as importMetaResolve } from "import-meta-resolve"
@@ -53,6 +54,19 @@ export function parseFileDependencies(filePath: string, content: string): FileDe
         fullPath,
       })
     } else if (npmPackage) {
+      const normalizedPackageName = npmPackage.startsWith("node:")
+        ? npmPackage.slice("node:".length)
+        : npmPackage
+      const builtinName = normalizedPackageName.split("/")[0]
+      if (
+        builtinModules.includes(normalizedPackageName) ||
+        builtinModules.includes(builtinName) ||
+        builtinModules.includes(`node:${normalizedPackageName}`) ||
+        builtinModules.includes(`node:${builtinName}`)
+      ) {
+        continue
+      }
+
       dependencies.push({
         type: "npm",
         id: `npm:${npmPackage}`,
@@ -255,7 +269,17 @@ export class SourceHashCalculator {
         //   throw new Error(`"${dependency.package}" imported without "node:" prefix`)
         // }
 
-        const resolvedPath = fileURLToPath(resolvedUrl)
+        const resolvedPath = this.resolveDependencyPath(dependency.package, resolvedUrl)
+        if (!resolvedPath) {
+          this.logger.debug(
+            `using package version as a fallback hash for "%s" due to unsupported resolver output "%s"`,
+            dependency.package,
+            resolvedUrl,
+          )
+
+          const [, depPackageJson] = await this.getPackageJsonFromPackageName(dependency.package)
+          return this.hashString(depPackageJson.version ?? "0.0.0")
+        }
 
         const [depPackageJsonPath, depPackageJson] = await this.getPackageJson(resolvedPath)
         const packageName = depPackageJson.name!
@@ -310,6 +334,35 @@ export class SourceHashCalculator {
     }
   }
 
+  private resolveDependencyPath(packageName: string, resolvedUrl: string): string | null {
+    if (resolvedUrl.startsWith("file:")) {
+      return fileURLToPath(resolvedUrl)
+    }
+
+    if (isAbsolute(resolvedUrl)) {
+      return resolvedUrl
+    }
+
+    if (resolvedUrl.startsWith("node:")) {
+      return null
+    }
+
+    // Bun resolver may return non-file URL schemes for certain modules.
+    if (resolvedUrl.includes(":")) {
+      return null
+    }
+
+    const baseDir = dirname(this.packageJsonPath)
+    return resolve(baseDir, "node_modules", packageName)
+  }
+
+  private async getPackageJsonFromPackageName(packageName: string): Promise<[string, PackageJson]> {
+    const baseDir = dirname(this.packageJsonPath)
+    const packagePath = resolve(baseDir, "node_modules", packageName)
+
+    return await this.getPackageJson(packagePath)
+  }
+
   private async getPackageJson(basePath: string): Promise<[string, PackageJson]> {
     while (true) {
       const packageJson = await readPackageJSON(basePath)

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Exeteres
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/assets/template/pnpm-workspace.tpl.yaml

@@ -1,4 +0,0 @@
-{{#if isPnpm}}
-packages:
-  - "packages/*"
-{{/if}}