@highstate/backend 0.20.0 → 0.21.1

package/src/library/find-package-json.ts

@@ -0,0 +1,149 @@
+import { access } from "node:fs/promises"
+import { dirname, isAbsolute, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+
+/**
+ * Polyfill for resolving the path to a package.json file for a given module specifier and base URL.
+ *
+ * Context: https://github.com/oven-sh/bun/issues/23898
+ */
+export async function findPackageJSONCompat(
+  specifier: string | URL,
+  base?: string | URL,
+): Promise<string | undefined> {
+  const parsedSpecifier = toPathSpecifier(specifier)
+
+  if (parsedSpecifier.type === "bare") {
+    if (!base) {
+      return undefined
+    }
+
+    const basePath = resolveBasePath(base)
+    const baseDir = await normalizePathForLookup(basePath)
+
+    return await findPackageJsonForBareSpecifier(baseDir, parsedSpecifier.value)
+  }
+
+  const resolvedPath = resolvePathSpecifier(parsedSpecifier.value, base)
+  const lookupStart = await normalizePathForLookup(resolvedPath)
+
+  return await findNearestPackageJson(lookupStart)
+}
+
+type PathSpecifier = { type: "bare"; value: string } | { type: "path"; value: string }
+
+function toPathSpecifier(specifier: string | URL): PathSpecifier {
+  if (specifier instanceof URL) {
+    if (specifier.protocol !== "file:") {
+      throw new Error(`Unsupported URL protocol "${specifier.protocol}"`)
+    }
+
+    return { type: "path", value: fileURLToPath(specifier) }
+  }
+
+  if (specifier.startsWith("file:")) {
+    return { type: "path", value: fileURLToPath(new URL(specifier)) }
+  }
+
+  if (isBareSpecifier(specifier)) {
+    return { type: "bare", value: specifier }
+  }
+
+  return { type: "path", value: specifier }
+}
+
+function isBareSpecifier(specifier: string): boolean {
+  return !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("file:")
+}
+
+function resolvePathSpecifier(specifierPath: string, base?: string | URL): string {
+  if (isAbsolute(specifierPath)) {
+    return specifierPath
+  }
+
+  const basePath = base ? resolveBasePath(base) : process.cwd()
+
+  if (specifierPath.startsWith(".")) {
+    const baseDir = isLikelyFilePath(basePath) ? dirname(basePath) : basePath
+    return resolve(baseDir, specifierPath)
+  }
+
+  return specifierPath
+}
+
+function resolveBasePath(base: string | URL): string {
+  if (base instanceof URL) {
+    if (base.protocol !== "file:") {
+      throw new Error(`Unsupported base URL protocol "${base.protocol}"`)
+    }
+
+    return fileURLToPath(base)
+  }
+
+  if (base.startsWith("file:")) {
+    return fileURLToPath(new URL(base))
+  }
+
+  return base
+}
+
+async function normalizePathForLookup(pathValue: string): Promise<string> {
+  const existsAsFile = await pathExists(pathValue)
+  if (existsAsFile && isLikelyFilePath(pathValue)) {
+    return dirname(pathValue)
+  }
+
+  return pathValue
+}
+
+function isLikelyFilePath(pathValue: string): boolean {
+  return pathValue.endsWith(".json") || pathValue.endsWith(".mjs") || pathValue.endsWith(".js")
+}
+
+async function findNearestPackageJson(startPath: string): Promise<string | undefined> {
+  let current = startPath
+
+  while (true) {
+    const candidate = resolve(current, "package.json")
+    if (await pathExists(candidate)) {
+      return candidate
+    }
+
+    const parent = dirname(current)
+    if (parent === current) {
+      return undefined
+    }
+
+    current = parent
+  }
+}
+
+async function findPackageJsonForBareSpecifier(
+  startDirectory: string,
+  packageName: string,
+): Promise<string | undefined> {
+  let current = startDirectory
+
+  while (true) {
+    const candidate = resolve(current, "node_modules", packageName, "package.json")
+    if (await pathExists(candidate)) {
+      return candidate
+    }
+
+    const parent = dirname(current)
+    if (parent === current) {
+      return undefined
+    }
+
+    current = parent
+  }
+}
+
+async function pathExists(pathValue: string): Promise<boolean> {
+  try {
+    await access(pathValue)
+    return true
+  } catch {
+    return false
+  }
+}

package/src/library/package-resolution-worker.ts

@@ -1,8 +1,8 @@
 import { realpath } from "node:fs/promises"
-import { findPackageJSON } from "node:module"
 import { dirname } from "node:path"
 import { parentPort, workerData } from "node:worker_threads"
 import pino, { type Level } from "pino"
+import { findPackageJSONCompat } from "./find-package-json"
 
 export type PackageResolutionWorkerData = {
   importPath: string
@@ -37,9 +37,13 @@ const results: PackageResult[] = []
 
 for (const packageName of packageNames) {
   try {
-    const path = findPackageJSON(packageName, rootDir)
+    const path = await findPackageJSONCompat(packageName, rootDir)
     if (!path) {
-      throw new Error(`Package "${packageName}" not found`)
+      results.push({
+        type: "not-found",
+        packageName,
+      })
+      continue
     }
 
     results.push({

package/src/orchestrator/operation.ts

@@ -425,6 +425,8 @@ export class RuntimeOperation {
         state.status === "deployed" &&
         state.selfHash != null &&
         state.dependencyOutputHash != null &&
+        // do not short-circuit after destroy phase in recreate operations
+        state.lastOperationState?.status !== "destroyed" &&
         // ignore explicitly requested updates
         !this.operation.requestedInstanceIds.includes(instance.id) &&
         // ignore when side effects are requested

package/src/orchestrator/operation.update.skip.test.ts

@@ -202,4 +202,90 @@ describe("RuntimeOperation - Update Short-Circuit", () => {
       })
     },
   )
+
+  operationTest(
+    "does not short-circuit update for instances destroyed earlier in recreate",
+    async ({
+      project,
+      logger,
+      runnerBackend,
+      libraryBackend,
+      artifactService,
+      instanceLockService,
+      operationService,
+      secretService,
+      instanceStateService,
+      projectModelService,
+      unitExtraService,
+      entitySnapshotService,
+      unitOutputService,
+      createUnit,
+      createDeployedUnitState,
+      createContext,
+      createOperation,
+      setupImmediateLocking,
+      setupPersistenceMocks,
+      expect,
+    }) => {
+      // arrange
+      const unit = createUnit("A")
+      const state = createDeployedUnitState(unit)
+
+      const context = await createContext({ instances: [unit], states: [state] })
+
+      const expected = await context.getUpToDateInputHashOutput(unit)
+      state.selfHash = expected.selfHash
+      state.dependencyOutputHash = expected.dependencyOutputHash
+      instanceStateService.getInstanceStates.mockResolvedValue([state])
+
+      setupImmediateLocking()
+      setupPersistenceMocks({ instances: [unit] })
+
+      const operation = createOperation({
+        type: "recreate",
+        requestedInstanceIds: [unit.id],
+        phases: [
+          {
+            type: "destroy",
+            instances: [{ id: unit.id, message: "explicitly requested", parentId: undefined }],
+          },
+          {
+            type: "update",
+            instances: [{ id: unit.id, message: "explicitly requested", parentId: undefined }],
+          },
+        ],
+      })
+
+      const runtimeOperation = new RuntimeOperation(
+        project,
+        operation,
+        runnerBackend,
+        libraryBackend,
+        artifactService,
+        instanceLockService,
+        operationService,
+        secretService,
+        instanceStateService,
+        projectModelService,
+        unitExtraService,
+        entitySnapshotService,
+        unitOutputService,
+        logger,
+      )
+
+      // act
+      await runtimeOperation.operateSafe()
+
+      // assert
+      expect(runnerBackend.destroy).toHaveBeenCalledTimes(1)
+      expect(runnerBackend.update).toHaveBeenCalledTimes(1)
+
+      const skipCall = instanceStateService.updateOperationState.mock.calls.find(
+        ([, stateId, , options]) =>
+          stateId === unit.id && options.operationState?.status === "skipped",
+      )
+
+      expect(skipCall).toBeUndefined()
+    },
+  )
 })

package/src/runner/factory.ts

@@ -12,19 +12,19 @@ export const runnerBackendConfig = z.object({
   ...localRunnerBackendConfig.shape,
 })
 
-export function createRunnerBackend(
+export async function createRunnerBackend(
   config: z.infer<typeof runnerBackendConfig>,
   libraryBackend: LibraryBackend,
   artifactManager: ArtifactService,
   artifactBackend: ArtifactBackend,
   secretService: SecretService,
   logger: Logger,
-): RunnerBackend {
+): Promise<RunnerBackend> {
   switch (config.HIGHSTATE_RUNNER_BACKEND_TYPE) {
     case "local": {
       const localPulumiHost = LocalPulumiHost.create(secretService, logger)
 
-      return LocalRunnerBackend.create(
+      return await LocalRunnerBackend.create(
         config,
         localPulumiHost,
         libraryBackend,

package/src/runner/force-abort.ts

@@ -3,7 +3,8 @@
 
 import type { PulumiCommand } from "@pulumi/pulumi/automation/index.js"
 import * as os from "node:os"
-import path from "node:path"
+import { homedir } from "node:os"
+import path, { resolve } from "node:path"
 import { execa } from "execa"
 
 /**
@@ -20,7 +21,11 @@ export async function createForceAbortableCommand(): Promise<PulumiCommand> {
     "@pulumi/pulumi/automation/index.js"
   )
 
-  const command: any = await PulumiCommand.get()
+  const commandOptions = {
+    root: resolve(homedir(), ".pulumi"),
+  }
+
+  const command: any = await PulumiCommand.get(commandOptions)
 
   // replicate the run method from PulumiCommand
   command.run = function (

package/src/runner/local.ts

@@ -16,7 +16,7 @@ import type {
 import type { DualAbortSignal } from "./force-abort"
 import { EventEmitter, on } from "node:events"
 import { mkdir, rm } from "node:fs/promises"
-import { cpus } from "node:os"
+import { cpus, homedir } from "node:os"
 import { join, resolve } from "node:path"
 import {
   getInstanceId,
@@ -649,14 +649,19 @@ export class LocalRunnerBackend implements RunnerBackend {
     return options.stateId
   }
 
-  public static create(
+  public static async create(
     config: z.infer<typeof localRunnerBackendConfig>,
     pulumiProjectHost: LocalPulumiHost,
     libraryBackend: LibraryBackend,
     artifactManager: ArtifactService,
     artifactBackend: ArtifactBackend,
     logger: Logger,
-  ): RunnerBackend {
+  ): Promise<RunnerBackend> {
+    const { PulumiCommand } = await import("@pulumi/pulumi/automation/index.js")
+    await PulumiCommand.install({
+      root: resolve(homedir(), ".pulumi"),
+    })
+
     let cacheDir = config.HIGHSTATE_RUNNER_BACKEND_LOCAL_CACHE_DIR
     if (!cacheDir) {
       const homeDir = process.env.HOME ?? process.env.USERPROFILE

package/src/runner/pulumi.ts

@@ -2,6 +2,7 @@ import type {
   ConfigMap,
   OpMap,
   OpType,
+  ProjectRuntime,
   Stack,
   WhoAmIResult,
 } from "@pulumi/pulumi/automation/index.js"
@@ -63,7 +64,7 @@ export class LocalPulumiHost {
         {
           projectSettings: {
             name: pulumiProjectName,
-            runtime: "nodejs",
+            runtime: "bun" as ProjectRuntime,
           },
           envVars: {
             PULUMI_CONFIG_PASSPHRASE: await this.secretService.getPulumiPassword(projectId),
@@ -112,10 +113,7 @@ export class LocalPulumiHost {
           projectSettings: {
             name: pulumiProjectName,
             runtime: {
-              name: "nodejs",
-              options: {
-                nodeargs: "--no-deprecation",
-              },
+              name: "bun",
             },
             main: "index.js",
           },

package/src/services.ts

@@ -214,7 +214,7 @@ export async function createServices({
   )
   sessionService ??= new TerminalSessionService(database)
 
-  runnerBackend ??= createRunnerBackend(
+  runnerBackend ??= await createRunnerBackend(
     config,
     libraryBackend,
     artifactService,

package/src/terminal/run.sh.ts

@@ -23,10 +23,15 @@ for key in "\${filesKeys[@]}"; do
     continue
   fi
   
-  # Handle embedded content
-  if [ "$contentType" = "embedded" ]; then
-    content=$(jq -r ".files[\\"$key\\"].content.value" <<<"$data")
-    isBinary=$(jq -r ".files[\\"$key\\"].meta.isBinary // false" <<<"$data")
+  # Handle embedded and embedded-secret content
+  if [ "$contentType" = "embedded" ] || [ "$contentType" = "embedded-secret" ]; then
+    if [ "$contentType" = "embedded-secret" ]; then
+      content=$(jq -r ".files[\\"$key\\"].content.value.value" <<<"$data")
+    else
+      content=$(jq -r ".files[\\"$key\\"].content.value" <<<"$data")
+    fi
+
+    isBinary=$(jq -r ".files[\\"$key\\"].content.isBinary // .files[\\"$key\\"].meta.isBinary // false" <<<"$data")
     mode=$(jq -r ".files[\\"$key\\"].meta.mode // 0" <<<"$data")
     
     mkdir -p "$(dirname "$key")"

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.