@highstate/cli 0.14.1 → 0.16.0

package/dist/chunk-VNBLDKUT.js

@@ -0,0 +1,1744 @@
+import { int32ToBytes } from './chunk-CMECLVT7.js';
+import { hostname } from 'node:os';
+import { loadConfig } from '@highstate/backend';
+import { identityToRecipient } from 'age-encryption';
+import { Command, Option, UsageError } from 'clipanion';
+import { writeFile, mkdir, access, readdir, rm, readFile, stat } from 'node:fs/promises';
+import { PassThrough } from 'node:stream';
+import { LogLevels, consola } from 'consola';
+import pino, { levels } from 'pino';
+import { resolve, relative, dirname, join } from 'node:path';
+import Handlebars from 'handlebars';
+import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
+import { parse, stringify } from 'yaml';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import MagicString from 'magic-string';
+import { parseAsync } from 'oxc-parser';
+import { walk } from 'oxc-walker';
+import { z } from 'zod';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { crc32 } from '@aws-crypto/crc32';
+import { resolve as resolve$1 } from 'import-meta-resolve';
+import { existsSync } from 'node:fs';
+import { input, confirm, select } from '@inquirer/prompts';
+import { Table } from 'console-table-printer';
+import { encode } from '@msgpack/msgpack';
+import { mapValues } from 'remeda';
+import { build } from 'tsup';
+import { colorize } from 'consola/utils';
+import { getPort } from 'get-port-please';
+import { addDevDependency, detectPackageManager, installDependencies } from 'nypm';
+import semver from 'semver';
+
+var logger = pino(
+  {
+    name: "highstate-cli",
+    level: process.env.LOG_LEVEL ?? "info"
+  },
+  createConsolaStream()
+);
+consola.level = LogLevels[process.env.LOG_LEVEL ?? "info"];
+function createConsolaStream() {
+  const stream = new PassThrough();
+  stream.on("data", (data) => {
+    const { level, msg, error } = JSON.parse(String(data));
+    const levelLabel = levels.labels[level];
+    switch (levelLabel) {
+      case "info":
+        consola.info(msg);
+        break;
+      case "warn":
+        consola.warn(msg);
+        break;
+      case "error":
+        if (error) {
+          consola.error(msg, error);
+        } else {
+          consola.error(msg);
+        }
+        break;
+      case "debug":
+        consola.debug(msg);
+        break;
+      case "fatal":
+        consola.fatal(msg);
+        break;
+      case "trace":
+        consola.trace(msg);
+        break;
+    }
+  });
+  return stream;
+}
+
+// src/shared/bin-transformer.ts
+function createBinTransformerPlugin(sourceFilePaths) {
+  const filter = new RegExp(`(${sourceFilePaths.join("|")})$`);
+  logger.debug("created bin transformer plugin with filter: %s", filter);
+  return {
+    name: "bin-transformer",
+    setup(build2) {
+      build2.onLoad({ filter }, async (args) => {
+        const content = await readFile(args.path, "utf-8");
+        return {
+          contents: `#!/usr/bin/env node
+
+${content}`,
+          loader: "ts"
+        };
+      });
+    }
+  };
+}
+
+// src/shared/entry-points.ts
+function extractEntryPoints(packageJson) {
+  const exports = packageJson.exports;
+  let bin = packageJson.bin;
+  if (!exports && !bin) {
+    logger.warn("no exports or bin found in package.json");
+    return {};
+  }
+  if (exports !== void 0 && (typeof exports !== "object" || Array.isArray(exports))) {
+    throw new Error("Exports field in package.json must be an object");
+  }
+  if (bin !== void 0 && typeof bin !== "object") {
+    if (!packageJson.name) {
+      throw new Error("Package name is required when bin is a string");
+    }
+    bin = { [packageJson.name]: bin };
+  }
+  const result = {};
+  if (exports) {
+    for (const [key, value] of Object.entries(exports)) {
+      let distPath;
+      if (typeof value === "string") {
+        distPath = value;
+      } else if (typeof value === "object" && !Array.isArray(value)) {
+        if (!value.default) {
+          throw new Error(`Export "${key}" must have a default field in package.json`);
+        }
+        if (typeof value.default !== "string") {
+          throw new Error(`Export "${key}" default field must be a string in package.json`);
+        }
+        distPath = value.default;
+      } else {
+        throw new Error(`Export "${key}" must be a string or an object in package.json`);
+      }
+      const isJsonExport = distPath.endsWith(".json");
+      const isJsExport = distPath.endsWith(".js");
+      if (!isJsonExport && !isJsExport) {
+        throw new Error(
+          `The default value of export "${key}" must end with ".js" or ".json" in package.json, got "${distPath}"`
+        );
+      }
+      if (isJsExport && !distPath.startsWith("./dist/")) {
+        throw new Error(
+          `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] = {
+        entryPoint: `./src/${targetName}.ts`,
+        targetName,
+        distPath,
+        isBin: false,
+        key
+      };
+    }
+  }
+  if (bin) {
+    for (const [key, value] of Object.entries(bin)) {
+      if (typeof value !== "string") {
+        throw new Error(`Bin entry "${key}" must be a string in package.json`);
+      }
+      const distPath = value;
+      if (!distPath.startsWith("./dist/")) {
+        throw new Error(
+          `The value of bin entry "${key}" must start with "./dist/" in package.json, got "${distPath}"`
+        );
+      }
+      if (!distPath.endsWith(".js")) {
+        throw new Error(
+          `The value of bin entry "${key}" must end with ".js" in package.json, got "${distPath}"`
+        );
+      }
+      const targetName = distPath.slice(7).slice(0, -3);
+      result[targetName] = {
+        entryPoint: `./src/${targetName}.ts`,
+        targetName,
+        distPath,
+        isBin: true,
+        key
+      };
+    }
+  }
+  return result;
+}
+async function generateFromTemplate(templatePath, destinationPath, variables) {
+  const resolvedTemplatePath = resolve(templatePath);
+  const resolvedDestinationPath = resolve(destinationPath);
+  const templateStats = await stat(resolvedTemplatePath);
+  if (!templateStats.isDirectory()) {
+    throw new Error(`templatePath must be a directory: ${resolvedTemplatePath}`);
+  }
+  await mkdir(resolvedDestinationPath, { recursive: true });
+  const renderTemplate = (raw) => {
+    const template = Handlebars.compile(raw, {
+      strict: true,
+      noEscape: true
+    });
+    return template(variables);
+  };
+  const visit = async (absoluteSourcePath) => {
+    const sourceStats = await stat(absoluteSourcePath);
+    if (sourceStats.isDirectory()) {
+      const relativePath = relative(resolvedTemplatePath, absoluteSourcePath);
+      const destinationDirPath = join(resolvedDestinationPath, relativePath);
+      await mkdir(destinationDirPath, { recursive: true });
+      const entries = await readdir(absoluteSourcePath, { withFileTypes: true });
+      for (const entry of entries) {
+        await visit(join(absoluteSourcePath, entry.name));
+      }
+      return;
+    }
+    if (!sourceStats.isFile()) {
+      return;
+    }
+    const relativeFilePath = relative(resolvedTemplatePath, absoluteSourcePath);
+    const destinationRelativePath = relativeFilePath.replaceAll(".tpl", "");
+    const destinationFilePath = join(resolvedDestinationPath, destinationRelativePath);
+    await mkdir(dirname(destinationFilePath), { recursive: true });
+    const contents = await readFile(absoluteSourcePath, "utf8");
+    const rendered = renderTemplate(contents);
+    if (rendered.trim().length === 0) {
+      return;
+    }
+    await writeFile(destinationFilePath, rendered, "utf8");
+  };
+  await visit(resolvedTemplatePath);
+}
+
+// src/shared/npm-registry.ts
+async function fetchNpmPackument(packageName) {
+  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();
+}
+async function fetchLatestVersion(packageName) {
+  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;
+}
+async function fetchManifest(packageName, version) {
+  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;
+}
+function getDependencyRange(manifest, dependencyName) {
+  return manifest.peerDependencies?.[dependencyName] ?? manifest.dependencies?.[dependencyName] ?? manifest.optionalDependencies?.[dependencyName] ?? null;
+}
+async function writeJsonFile(filePath, value) {
+  const contents = `${JSON.stringify(value, null, 2)}
+`;
+  await writeFile(filePath, contents, "utf8");
+}
+function resolvePnpmWorkspacePath(projectRoot) {
+  return resolve(projectRoot, "pnpm-workspace.yaml");
+}
+async function readPnpmWorkspace(filePath) {
+  const raw = await readFile(filePath, "utf8");
+  const parsed = parse(raw);
+  if (typeof parsed !== "object" || parsed === null) {
+    return {};
+  }
+  return parsed;
+}
+async function writePnpmWorkspace(filePath, workspace) {
+  const raw = stringify(workspace);
+  await writeFile(filePath, raw, "utf8");
+}
+
+// src/shared/version-sets.ts
+var PLATFORM_PACKAGES = [
+  "@highstate/api",
+  "@highstate/backend",
+  "@highstate/backend-api",
+  "@highstate/cli",
+  "@highstate/contract",
+  "@highstate/designer",
+  "@highstate/pulumi",
+  "@highstate/worker-sdk"
+];
+var 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"
+];
+var PULUMI_PACKAGES = ["@pulumi/pulumi"];
+
+// src/shared/overrides.ts
+function buildOverrides(bundle) {
+  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 = {
+    ...platform,
+    ...stdlib,
+    ...pulumi
+  };
+  return merged;
+}
+async function applyOverrides(args) {
+  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);
+}
+async function getProjectOverrideVersion(projectRoot, args) {
+  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);
+  if (packageManager === "npm") {
+    const overrides = packageJson.overrides;
+    return overrides?.[packageName] ?? null;
+  }
+  if (packageManager === "yarn") {
+    const resolutions = packageJson.resolutions;
+    return resolutions?.[packageName] ?? null;
+  }
+  return null;
+}
+async function getProjectPlatformVersion(projectRoot, args) {
+  return await getProjectOverrideVersion(projectRoot, {
+    packageManager: args.packageManager,
+    packageName: "@highstate/pulumi"
+  });
+}
+async function getProjectPulumiSdkVersion(projectRoot, args) {
+  return await getProjectOverrideVersion(projectRoot, {
+    packageManager: args.packageManager,
+    packageName: "@pulumi/pulumi"
+  });
+}
+var execFileAsync = promisify(execFile);
+async function getPulumiCliVersion(cwd) {
+  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;
+  }
+}
+var schemaTransformerPlugin = {
+  name: "schema-transformer",
+  setup(build2) {
+    build2.onLoad({ filter: /src\/.*\.ts$/ }, async (args) => {
+      const content = await readFile(args.path, "utf-8");
+      return {
+        contents: await applySchemaTransformations(content),
+        loader: "ts"
+      };
+    });
+  }
+};
+async function applySchemaTransformations(content) {
+  let result = await applyZodMetaTransformations(content);
+  result = await applyHelperFunctionTransformations(result);
+  result = await applyDefineFunctionMetaTransformations(result);
+  return result;
+}
+async function applyZodMetaTransformations(content) {
+  const { program, comments } = await parseAsync("file.ts", content);
+  const parentStack = [];
+  let hasTransformations = false;
+  const result = new MagicString(content);
+  walk(program, {
+    enter(node) {
+      parentStack.push(node);
+      if (isZodObjectProperty(node, parentStack)) {
+        const jsdoc = findLeadingComment(content, node, comments);
+        if (jsdoc) {
+          const description = cleanJsdoc(jsdoc.value);
+          const fieldName = "name" in node.key && typeof node.key.name === "string" ? node.key.name : "unknown";
+          const originalValue = content.substring(node.value.start, node.value.end);
+          if (!originalValue.includes(".meta(")) {
+            const newValue = `${originalValue}.meta({ title: __camelCaseToHumanReadable("${fieldName}"), description: \`${description}\` })`;
+            result.update(node.value.start, node.value.end, newValue);
+            hasTransformations = true;
+          }
+        }
+      }
+    },
+    leave() {
+      parentStack.pop();
+    }
+  });
+  let finalResult = result.toString();
+  if (hasTransformations && !content.includes("__camelCaseToHumanReadable")) {
+    finalResult = 'import { camelCaseToHumanReadable as __camelCaseToHumanReadable } from "@highstate/contract"\n' + finalResult;
+  }
+  return finalResult;
+}
+async function applyHelperFunctionTransformations(content) {
+  const { program, comments } = await parseAsync("file.ts", content);
+  const parentStack = [];
+  let hasTransformations = false;
+  const result = new MagicString(content);
+  walk(program, {
+    enter(node) {
+      parentStack.push(node);
+      if (node.type === "Property" && "key" in node && node.key?.type === "Identifier") {
+        const propertyNode = node;
+        const helperFunction = getHelperFunctionForProperty(parentStack);
+        if (helperFunction) {
+          const jsdoc = findLeadingComment(content, node, comments);
+          if (jsdoc) {
+            const description = cleanJsdoc(jsdoc.value);
+            const originalValue = content.substring(
+              propertyNode.value.start,
+              propertyNode.value.end
+            );
+            const newValue = `${helperFunction}(${originalValue}, \`${description}\`)`;
+            result.update(propertyNode.value.start, propertyNode.value.end, newValue);
+            hasTransformations = true;
+          }
+        }
+      }
+    },
+    leave() {
+      parentStack.pop();
+    }
+  });
+  let finalResult = result.toString();
+  if (hasTransformations && !content.includes("$addArgumentDescription")) {
+    finalResult = 'import { $addArgumentDescription, $addInputDescription } from "@highstate/contract"\n' + finalResult;
+  }
+  return finalResult;
+}
+async function applyDefineFunctionMetaTransformations(content) {
+  const { program, comments } = await parseAsync("file.ts", content);
+  const parentStack = [];
+  const result = new MagicString(content);
+  walk(program, {
+    enter(node) {
+      parentStack.push(node);
+      if (node.type === "CallExpression" && "callee" in node && node.callee.type === "Identifier") {
+        const callNode = node;
+        const callee = callNode.callee;
+        const functionName = "name" in callee && typeof callee.name === "string" ? callee.name : void 0;
+        if (functionName && ["defineUnit", "defineEntity", "defineComponent"].includes(functionName)) {
+          const jsdoc = findJsdocForDefineFunction(content, parentStack, comments);
+          if (jsdoc && callNode.arguments && callNode.arguments.length > 0) {
+            const description = cleanJsdoc(jsdoc.value);
+            const firstArg = callNode.arguments[0];
+            if (firstArg.type === "ObjectExpression" && "properties" in firstArg) {
+              const properties = firstArg.properties;
+              const metaProperty = properties?.find(
+                (prop) => prop.type === "Property" && "key" in prop && prop.key?.type === "Identifier" && prop.key?.name === "meta"
+              );
+              if (metaProperty && "value" in metaProperty) {
+                const originalMetaValue = content.substring(
+                  metaProperty.value.start,
+                  metaProperty.value.end
+                );
+                const newMetaValue = injectDescriptionIntoMetaObject(originalMetaValue, description);
+                result.update(metaProperty.value.start, metaProperty.value.end, newMetaValue);
+              } else if (properties && properties.length > 0) {
+                const lastProperty = properties[properties.length - 1];
+                if (lastProperty && "end" in lastProperty) {
+                  const insertPos = lastProperty.end;
+                  const newMetaProperty = `,
+
+  meta: {
+    description: \`${description}\`,
+  }`;
+                  result.appendLeft(insertPos, newMetaProperty);
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    leave() {
+      parentStack.pop();
+    }
+  });
+  return result.toString();
+}
+function findJsdocForDefineFunction(content, parentStack, comments) {
+  for (let i = parentStack.length - 1; i >= 0; i--) {
+    const node = parentStack[i];
+    if (node.type === "VariableDeclarator" && "id" in node && node.id?.type === "Identifier") {
+      const jsdoc = findLeadingComment(content, node, comments);
+      if (jsdoc) return jsdoc;
+    }
+    if (node.type === "VariableDeclaration") {
+      const jsdoc = findLeadingComment(content, node, comments);
+      if (jsdoc) return jsdoc;
+    }
+    if (node.type === "ExportNamedDeclaration" && "declaration" in node && node.declaration) {
+      const jsdoc = findLeadingComment(content, node, comments);
+      if (jsdoc) return jsdoc;
+    }
+  }
+  return null;
+}
+function isZodObjectProperty(node, parentStack) {
+  return node.type === "Property" && "key" in node && node.key?.type === "Identifier" && isInsideZodObject(parentStack);
+}
+function findLeadingComment(content, node, comments) {
+  return comments.find((comment) => isLeadingComment(content, node, comment)) ?? null;
+}
+function isLeadingComment(content, node, comment) {
+  if (comment.end > node.start) {
+    return false;
+  }
+  const contentRange = content.substring(comment.end, node.start);
+  return contentRange.trim().length === 0;
+}
+function cleanJsdoc(str) {
+  return str.replace(/^\s*\*/gm, "").replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\${/g, "\\${").trim();
+}
+function injectDescriptionIntoMetaObject(objectString, description) {
+  const trimmed = objectString.trim();
+  const hasDescription = /description\s*:/.test(trimmed);
+  if (hasDescription) {
+    return trimmed.replace(/description\s*:\s*`[^`]*`/, `description: \`${description}\``);
+  } else {
+    const openBraceIndex = trimmed.indexOf("{");
+    if (openBraceIndex === -1) {
+      return trimmed;
+    }
+    const beforeBrace = trimmed.substring(0, openBraceIndex + 1);
+    const afterBrace = trimmed.substring(openBraceIndex + 1);
+    return `${beforeBrace}
+    description: \`${description}\`,${afterBrace}`;
+  }
+}
+function isInsideZodObject(parentStack) {
+  for (let i = parentStack.length - 1; i >= 0; i--) {
+    const node = parentStack[i];
+    if (node.type === "CallExpression" && "callee" in node && node.callee.type === "MemberExpression" && isZodObjectCall(node.callee)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getHelperFunctionForProperty(parentStack) {
+  if (parentStack.length < 3) {
+    return null;
+  }
+  const objectExpression = parentStack[parentStack.length - 2];
+  if (!objectExpression || objectExpression.type !== "ObjectExpression") {
+    return null;
+  }
+  const containerParent = parentStack[parentStack.length - 3];
+  if (!containerParent) {
+    return null;
+  }
+  if (containerParent.type === "Property" && "value" in containerParent && containerParent.value === objectExpression && containerParent.key?.type === "Identifier") {
+    const keyName = containerParent.key.name;
+    if (keyName === "inputs" || keyName === "outputs") {
+      return "$addInputDescription";
+    }
+    if (keyName === "args" || keyName === "secrets") {
+      return "$addArgumentDescription";
+    }
+    return null;
+  }
+  if (containerParent.type === "CallExpression" && containerParent.callee.type === "Identifier" && containerParent.arguments.length > 0 && containerParent.arguments[0] === objectExpression) {
+    const calleeName = containerParent.callee.name;
+    if (calleeName === "$inputs" || calleeName === "$outputs") {
+      return "$addInputDescription";
+    }
+    if (calleeName === "$args" || calleeName === "$secrets") {
+      return "$addArgumentDescription";
+    }
+  }
+  return null;
+}
+function isZodObjectCall(memberExpression) {
+  if (memberExpression.type !== "MemberExpression" || !("object" in memberExpression) || !("property" in memberExpression)) {
+    return false;
+  }
+  const member = memberExpression;
+  if (member.object.type === "Identifier" && "name" in member.object && member.object.name === "z" && member.property.type === "Identifier" && member.property.name === "object") {
+    return true;
+  }
+  if (member.property.type === "Identifier" && member.property.name === "object" && member.object.type === "CallExpression" && "callee" in member.object && member.object.callee.type === "MemberExpression") {
+    return startsWithZodCall(member.object);
+  }
+  return false;
+}
+function startsWithZodCall(callExpression) {
+  if (!callExpression || callExpression.type !== "CallExpression") {
+    return false;
+  }
+  if (callExpression.callee.type === "MemberExpression") {
+    const callee = callExpression.callee;
+    if (callee.object.type === "Identifier" && "name" in callee.object && callee.object.name === "z") {
+      return true;
+    }
+    if (callee.object.type === "CallExpression") {
+      return startsWithZodCall(callee.object);
+    }
+  }
+  return false;
+}
+var sourceHashConfigSchema = z.discriminatedUnion("mode", [
+  z.object({
+    mode: z.literal("manual"),
+    version: z.string()
+  }),
+  z.object({
+    mode: z.literal("auto")
+  }),
+  z.object({
+    mode: z.literal("version")
+  }),
+  z.object({
+    mode: z.literal("none")
+  })
+]);
+var highstateConfigSchema = z.object({
+  type: z.enum(["source", "library", "worker"]).default("source"),
+  sourceHash: z.union([sourceHashConfigSchema, z.record(z.string(), sourceHashConfigSchema)]).optional()
+});
+var highstateManifestSchema = z.object({
+  sourceHashes: z.record(z.string(), z.number()).optional()
+});
+
+// src/shared/services.ts
+var services;
+var disposePromise;
+function getBackendServices() {
+  if (services) {
+    return services;
+  }
+  services = import('@highstate/backend').then(({ getSharedServices }) => {
+    return getSharedServices({
+      services: {
+        logger: logger.child({}, { msgPrefix: "[backend] " })
+      }
+    });
+  });
+  return services;
+}
+function disposeServices() {
+  if (!services) {
+    return Promise.resolve();
+  }
+  if (disposePromise) {
+    return disposePromise;
+  }
+  disposePromise = import('@highstate/backend').then(({ disposeServices: disposeServices2 }) => services.then((s) => disposeServices2(s)));
+  return disposePromise;
+}
+var SourceHashCalculator = class {
+  constructor(packageJsonPath, packageJson, logger2) {
+    this.packageJsonPath = packageJsonPath;
+    this.packageJson = packageJson;
+    this.logger = logger2;
+  }
+  dependencyHashes = /* @__PURE__ */ new Map();
+  fileHashes = /* @__PURE__ */ new Map();
+  /**
+   * Calculates CRC32 hash of a string.
+   */
+  hashString(input3) {
+    return crc32(Buffer.from(input3));
+  }
+  /**
+   * Gets the highstate configuration from package.json with defaults.
+   */
+  getHighstateConfig(packageJson) {
+    const rawConfig = packageJson.highstate;
+    if (!rawConfig) {
+      return { type: "source" };
+    }
+    try {
+      return highstateConfigSchema.parse(rawConfig);
+    } catch (error) {
+      this.logger.warn(
+        { error, packageName: packageJson.name },
+        "invalid highstate configuration, using defaults"
+      );
+      return { type: "source" };
+    }
+  }
+  /**
+   * Gets the effective source hash configuration with defaults for a specific output.
+   */
+  getSourceHashConfig(highstateConfig, exportKey) {
+    if (highstateConfig.sourceHash) {
+      const singleConfigResult = sourceHashConfigSchema.safeParse(highstateConfig.sourceHash);
+      if (singleConfigResult.success) {
+        return singleConfigResult.data;
+      }
+      const recordConfigResult = z.record(z.string(), sourceHashConfigSchema).safeParse(highstateConfig.sourceHash);
+      if (recordConfigResult.success && exportKey) {
+        const perOutputConfig = recordConfigResult.data[exportKey];
+        if (perOutputConfig) {
+          return perOutputConfig;
+        }
+      }
+    }
+    if (highstateConfig.type === "library") {
+      return { mode: "none" };
+    }
+    return { mode: "auto" };
+  }
+  async writeHighstateManifest(distBasePath, distPathToExportKey) {
+    const highstateConfig = this.getHighstateConfig(this.packageJson);
+    const promises = [];
+    for (const [distPath, exportKey] of distPathToExportKey) {
+      const fullPath = resolve(distPath);
+      const sourceHashConfig = this.getSourceHashConfig(highstateConfig, exportKey);
+      switch (sourceHashConfig.mode) {
+        case "manual":
+          promises.push(
+            Promise.resolve({
+              distPath,
+              hash: this.hashString(sourceHashConfig.version)
+            })
+          );
+          break;
+        case "version":
+          promises.push(
+            Promise.resolve({
+              distPath,
+              hash: this.hashString(this.packageJson.version ?? "")
+            })
+          );
+          break;
+        case "none":
+          promises.push(
+            Promise.resolve({
+              distPath,
+              hash: 0
+            })
+          );
+          break;
+        default:
+          promises.push(
+            this.getFileHash(fullPath).then((hash) => ({
+              distPath,
+              hash
+            }))
+          );
+          break;
+      }
+    }
+    const manifest = {
+      sourceHashes: {}
+    };
+    const hashes = await Promise.all(promises);
+    for (const { distPath, hash } of hashes) {
+      manifest.sourceHashes[distPath] = hash;
+    }
+    const manifestPath = resolve(distBasePath, "highstate.manifest.json");
+    await writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
+  }
+  async getFileHash(fullPath) {
+    const existingHash = this.fileHashes.get(fullPath);
+    if (existingHash) {
+      return existingHash;
+    }
+    const hash = this.calculateFileHash(fullPath);
+    this.fileHashes.set(fullPath, hash);
+    return hash;
+  }
+  async calculateFileHash(fullPath) {
+    const content = await readFile(fullPath, "utf8");
+    const fileDeps = this.parseDependencies(fullPath, content);
+    const hashes = await Promise.all([
+      this.hashString(content),
+      ...fileDeps.map((dep) => this.getDependencyHash(dep))
+    ]);
+    return crc32(Buffer.concat(hashes.map(int32ToBytes)));
+  }
+  getDependencyHash(dependency) {
+    const existingHash = this.dependencyHashes.get(dependency.id);
+    if (existingHash) {
+      return existingHash;
+    }
+    const hash = this.calculateDependencyHash(dependency);
+    this.dependencyHashes.set(dependency.id, hash);
+    return hash;
+  }
+  async calculateDependencyHash(dependency) {
+    switch (dependency.type) {
+      case "relative": {
+        return await this.getFileHash(dependency.fullPath);
+      }
+      case "npm": {
+        let resolvedUrl;
+        try {
+          const baseUrl = pathToFileURL(this.packageJsonPath);
+          resolvedUrl = resolve$1(dependency.package, baseUrl.toString());
+        } catch (error) {
+          this.logger.error(`failed to resolve package "%s"`, dependency.package);
+          throw error;
+        }
+        const resolvedPath = fileURLToPath(resolvedUrl);
+        const [depPackageJsonPath, depPackageJson] = await this.getPackageJson(resolvedPath);
+        const packageName = depPackageJson.name;
+        this.logger.debug(
+          `resolved package.json for "%s": "%s"`,
+          dependency.package,
+          depPackageJsonPath
+        );
+        if (!this.packageJson.dependencies?.[packageName] && !this.packageJson.peerDependencies?.[packageName]) {
+          this.logger.warn(`package "%s" is not listed in package.json dependencies`, packageName);
+        }
+        let relativePath = relative(dirname(depPackageJsonPath), resolvedPath);
+        relativePath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+        const highstateManifestPath = resolve(
+          dirname(depPackageJsonPath),
+          "dist",
+          "highstate.manifest.json"
+        );
+        let manifest;
+        try {
+          const manifestContent = await readFile(highstateManifestPath, "utf8");
+          manifest = highstateManifestSchema.parse(JSON.parse(manifestContent));
+        } catch (error) {
+          this.logger.debug(
+            { error },
+            `failed to read highstate manifest for package "%s"`,
+            packageName
+          );
+        }
+        const sourceHash = manifest?.sourceHashes?.[relativePath];
+        if (sourceHash) {
+          this.logger.debug(`resolved source hash for package "%s"`, packageName);
+          return sourceHash;
+        }
+        this.logger.debug(`using package version as a fallback hash for "%s"`, packageName);
+        return this.hashString(depPackageJson.version ?? "0.0.0");
+      }
+    }
+  }
+  async getPackageJson(basePath) {
+    while (true) {
+      const packageJson = await readPackageJSON(basePath);
+      if (packageJson.name) {
+        const packageJsonPath = await resolvePackageJSON(basePath);
+        return [packageJsonPath, packageJson];
+      }
+      basePath = resolve(dirname(basePath), "..");
+    }
+  }
+  parseDependencies(filePath, content) {
+    const dependencyRegex = /^[ \t]*import[\s\S]*?\bfrom\s*["']((?<relativePath>\.\.?\/[^"']+)|(?<nodeBuiltin>node:[^"']+)|(?<npmPackage>[^"']+))["']/gm;
+    const matches = content.matchAll(dependencyRegex);
+    const dependencies = [];
+    for (const match of matches) {
+      const { nodeBuiltin, npmPackage, relativePath } = match.groups;
+      if (relativePath) {
+        const fullPath = resolve(dirname(filePath), relativePath);
+        dependencies.push({
+          type: "relative",
+          id: `relative:${fullPath}`,
+          fullPath
+        });
+      } else if (npmPackage) {
+        dependencies.push({
+          type: "npm",
+          id: `npm:${npmPackage}`,
+          package: npmPackage
+        });
+      } else ;
+    }
+    return dependencies;
+  }
+};
+
+// src/shared/version-bundle.ts
+var platformSourcePackage = "@highstate/pulumi";
+var stdlibSourcePackage = "@highstate/library";
+async function resolveVersionBundle(args) {
+  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, label) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`Version flag "${label}" must not be empty`);
+  }
+  return trimmed;
+}
+var packageJsonSchema = z.object({
+  name: z.string(),
+  highstate: highstateConfigSchema.optional()
+});
+function generateTsconfigContent(workspaceRoot, packagePath) {
+  const relativePath = relative(workspaceRoot, packagePath);
+  const depth = relativePath.split("/").length;
+  const relativeNodeModules = `${"../".repeat(depth)}node_modules/@highstate/cli/assets/tsconfig.base.json`;
+  return {
+    extends: relativeNodeModules,
+    include: ["./src/**/*.ts", "./package.json", "./assets/**/*.json"]
+  };
+}
+async function findWorkspaceRoot(startPath = process.cwd()) {
+  let currentPath = resolve(startPath);
+  while (currentPath !== "/") {
+    const packageJsonPath = join(currentPath, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const content = await readFile(packageJsonPath, "utf-8");
+        const packageJson = JSON.parse(content);
+        if (packageJson.workspaces) {
+          return currentPath;
+        }
+      } catch {
+      }
+    }
+    const parentPath = resolve(currentPath, "..");
+    if (parentPath === currentPath) break;
+    currentPath = parentPath;
+  }
+  throw new Error("Could not find workspace root (no package.json with workspaces found)");
+}
+async function scanWorkspacePackages(workspaceRoot) {
+  const packages = [];
+  const packagesDir = join(workspaceRoot, "packages");
+  if (!existsSync(packagesDir)) {
+    return packages;
+  }
+  async function scanDirectory(dirPath, depth = 0) {
+    const dirName = relative(packagesDir, dirPath).split("/").pop();
+    if (dirName?.startsWith(".") || dirName === "node_modules") {
+      return;
+    }
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const entryPath = join(dirPath, entry.name);
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      const packageJsonPath = join(entryPath, "package.json");
+      if (existsSync(packageJsonPath)) {
+        try {
+          const content = await readFile(packageJsonPath, "utf-8");
+          const packageJson = packageJsonSchema.parse(JSON.parse(content));
+          const relativePath = relative(workspaceRoot, entryPath);
+          const type = packageJson.highstate?.type ?? "source";
+          packages.push({
+            path: entryPath,
+            relativePath,
+            name: packageJson.name,
+            type
+          });
+        } catch {
+        }
+      }
+      if (depth < 3) {
+        await scanDirectory(entryPath, depth + 1);
+      }
+    }
+  }
+  await scanDirectory(packagesDir);
+  return packages.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+async function updateTsconfigReferences(workspaceRoot, packages, ensureTsconfigs = false) {
+  const tsconfigPath = join(workspaceRoot, "tsconfig.json");
+  if (ensureTsconfigs) {
+    await ensurePackageTsconfigs(
+      workspaceRoot,
+      // only udate for Highstate-managed packages
+      packages.filter((pkg) => pkg.type !== void 0)
+    );
+  }
+  const references = packages.map((pkg) => ({
+    path: `./${pkg.relativePath}/tsconfig.json`
+  }));
+  const tsconfigContent = {
+    files: [],
+    references
+  };
+  await writeFile(tsconfigPath, `${JSON.stringify(tsconfigContent, null, 2)}
+`, "utf-8");
+}
+async function ensurePackageTsconfigs(workspaceRoot, packages) {
+  for (const pkg of packages) {
+    const tsconfigPath = join(pkg.path, "tsconfig.json");
+    const tsconfigContent = generateTsconfigContent(workspaceRoot, pkg.path);
+    await writeFile(tsconfigPath, `${JSON.stringify(tsconfigContent, null, 2)}
+`, "utf-8");
+  }
+}
+async function createPackage(workspaceRoot, name, type) {
+  const packagePath = join(workspaceRoot, "packages", name);
+  const srcPath = join(packagePath, "src");
+  await mkdir(packagePath, { recursive: true });
+  await mkdir(srcPath, { recursive: true });
+  const packageJson = {
+    name: `@highstate/${name}`,
+    version: "0.0.1",
+    type: "module",
+    highstate: {
+      type
+    }
+  };
+  await writeFile(
+    join(packagePath, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`,
+    "utf-8"
+  );
+  const tsconfigContent = generateTsconfigContent(workspaceRoot, packagePath);
+  await writeFile(
+    join(packagePath, "tsconfig.json"),
+    `${JSON.stringify(tsconfigContent, null, 2)}
+`,
+    "utf-8"
+  );
+  await writeFile(join(srcPath, "index.ts"), `// ${name} package
+`, "utf-8");
+  return {
+    path: packagePath,
+    relativePath: `packages/${name}`,
+    name: `@highstate/${name}`,
+    type
+  };
+}
+
+// src/commands/backend/identity.ts
+var BackendIdentityCommand = class extends Command {
+  static paths = [["backend", "identity"]];
+  static usage = Command.Usage({
+    category: "Backend",
+    description: "Ensures the backend identity is set up and returns the recipient."
+  });
+  async execute() {
+    const { getOrCreateBackendIdentity } = await import('@highstate/backend');
+    const config = await loadConfig();
+    const backendIdentity = await getOrCreateBackendIdentity(config, logger);
+    const recipient = await identityToRecipient(backendIdentity);
+    logger.info(`stored backend identity: "%s"`, recipient);
+    const suggestedTitle = hostname();
+    if (!suggestedTitle) {
+      logger.info(`run "highstate backend unlock-method add %s" on a trusted device`, recipient);
+      return;
+    }
+    logger.info(
+      `run "highstate backend unlock-method add %s --title %s" on a trusted device`,
+      recipient,
+      suggestedTitle
+    );
+  }
+};
+var BackendUnlockMethodAddCommand = class extends Command {
+  static paths = [["backend", "unlock-method", "add"]];
+  static usage = Command.Usage({
+    category: "Backend",
+    description: "Adds a new backend unlock method for the current workspace.",
+    examples: [["Add recipient", "highstate backend unlock-method add age1example --title Laptop"]]
+  });
+  recipient = Option.String();
+  title = Option.String("--title");
+  description = Option.String("--description");
+  async execute() {
+    let title = this.title;
+    if (!title) {
+      title = await input({
+        message: "Unlock Method Title",
+        default: "New Device",
+        validate: (value) => value.trim().length > 0 ? true : "Title is required"
+      });
+    }
+    let description = this.description;
+    if (description === void 0) {
+      description = await input({
+        message: "Description (optional)",
+        default: ""
+      });
+    }
+    const services2 = await getBackendServices();
+    try {
+      const result = await services2.backendUnlockService.addUnlockMethod({
+        recipient: this.recipient,
+        meta: description ? { title: title.trim(), description: description.trim() } : { title: title.trim() }
+      });
+      logger.info(`added backend unlock method "%s"`, result.id);
+    } finally {
+      await disposeServices();
+    }
+    process.exit(0);
+  }
+};
+var BackendUnlockMethodDeleteCommand = class extends Command {
+  static paths = [["backend", "unlock-method", "delete"]];
+  static usage = Command.Usage({
+    category: "Backend",
+    description: "Removes a backend unlock method by its identifier."
+  });
+  id = Option.String();
+  force = Option.Boolean("--force", false);
+  async execute() {
+    if (!this.force) {
+      const answer = await confirm({
+        message: `Delete backend unlock method ${this.id}?`,
+        default: false
+      });
+      if (!answer) {
+        logger.info("cancelled backend unlock method deletion");
+        return;
+      }
+    }
+    const services2 = await getBackendServices();
+    try {
+      await services2.backendUnlockService.deleteUnlockMethod(this.id);
+      logger.info(`deleted backend unlock method "%s"`, this.id);
+    } finally {
+      await disposeServices();
+    }
+    process.exit(0);
+  }
+};
+var BackendUnlockMethodListCommand = class extends Command {
+  static paths = [["backend", "unlock-method", "list"]];
+  static usage = Command.Usage({
+    category: "Backend",
+    description: "Lists backend unlock methods registered for the current workspace."
+  });
+  async execute() {
+    const services2 = await getBackendServices();
+    try {
+      const methods = await services2.backendUnlockService.listUnlockMethods();
+      if (methods.length === 0) {
+        logger.warn("no backend unlock methods configured");
+        return;
+      }
+      const table = new Table({
+        columns: [
+          { name: "title", title: "Title" },
+          { name: "id", title: "ID" },
+          { name: "recipient", title: "Recipient" },
+          { name: "description", title: "Description", maxLen: 30 }
+        ],
+        defaultColumnOptions: {
+          alignment: "left"
+        }
+      });
+      table.addRows(
+        methods.map((method) => ({
+          title: method.meta.title,
+          id: method.id,
+          recipient: method.recipient,
+          description: method.meta.description ?? ""
+        }))
+      );
+      table.printTable();
+    } finally {
+      await disposeServices();
+    }
+    process.exit(0);
+  }
+};
+var BuildCommand = class extends Command {
+  static paths = [["build"]];
+  static usage = Command.Usage({
+    category: "Builder",
+    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() {
+    const packageJson = await readPackageJSON();
+    const highstateConfig = highstateConfigSchema.parse(packageJson.highstate ?? {});
+    if (highstateConfig.type === "library") {
+      this.library = true;
+    }
+    if (highstateConfig.type === "worker") {
+      this.noSourceHash = true;
+    }
+    if (!packageJson.name) {
+      throw new Error("package.json must have a name field");
+    }
+    const entryPoints = extractEntryPoints(packageJson);
+    if (Object.keys(entryPoints).length === 0) {
+      return;
+    }
+    const esbuildPlugins = [];
+    const binSourceFilePaths = Object.values(entryPoints).filter((value) => value.isBin).map((value) => value.entryPoint.slice(2));
+    if (this.library) {
+      esbuildPlugins.push(schemaTransformerPlugin);
+    }
+    if (binSourceFilePaths.length > 0) {
+      esbuildPlugins.push(createBinTransformerPlugin(binSourceFilePaths));
+    }
+    await build({
+      entry: mapValues(entryPoints, (value) => value.entryPoint),
+      outDir: "dist",
+      watch: this.watch,
+      sourcemap: true,
+      clean: true,
+      format: "esm",
+      target: "es2024",
+      platform: "node",
+      external: ["@pulumi/pulumi"],
+      esbuildPlugins,
+      treeshake: true,
+      removeNodeProtocol: false,
+      silent: this.silent || ["warn", "error", "fatal"].includes(logger.level)
+    });
+    const packageJsonPath = await resolvePackageJSON();
+    const upToDatePackageJson = await readPackageJSON();
+    if (!this.noSourceHash) {
+      const sourceHashCalculator = new SourceHashCalculator(
+        packageJsonPath,
+        upToDatePackageJson,
+        logger
+      );
+      const distPathToExportKey = /* @__PURE__ */ new Map();
+      for (const value of Object.values(entryPoints)) {
+        distPathToExportKey.set(value.distPath, value.key);
+      }
+      await sourceHashCalculator.writeHighstateManifest("./dist", distPathToExportKey);
+    }
+    if (this.library) {
+      const { loadLibrary } = await import('./library-loader-PZWYMBAE.js');
+      const fullModulePaths = Object.values(entryPoints).map((value) => resolve(value.distPath));
+      logger.info("evaluating library components from modules: %s", fullModulePaths.join(", "));
+      const library = await loadLibrary(logger, fullModulePaths);
+      const libraryPath = resolve("./dist", "highstate.library.msgpack");
+      await writeFile(libraryPath, encode(library), "utf8");
+    }
+    logger.info("build completed successfully");
+  }
+};
+var DesignerCommand = class extends Command {
+  static paths = [["designer"]];
+  static usage = Command.Usage({
+    category: "Designer",
+    description: "Starts the Highstate designer in the current project."
+  });
+  async execute() {
+    const packageJsonPath = await resolvePackageJSON();
+    const packageJsonUrl = pathToFileURL(packageJsonPath).toString();
+    const packageJson = await readPackageJSON(packageJsonPath);
+    if (!packageJson.devDependencies?.["@highstate/cli"]) {
+      throw new UsageError(
+        "This project is not a Highstate project.\n@highstate/cli must be installed as a devDependency."
+      );
+    }
+    if (!packageJson.devDependencies?.["@highstate/designer"]) {
+      logger.info("Installing @highstate/designer...");
+      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
+expected "%s" (from overrides for "@pulumi/pulumi"), got "%s" (from "pulumi version")
+recommended: 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: 3e3 });
+    const eventsPort = await getPort({ port: 3001 });
+    const designerPackageJsonPath = resolve$1(
+      "@highstate/designer/package.json",
+      packageJsonUrl
+    );
+    const designerPackageJson = await readPackageJSON(designerPackageJsonPath);
+    process.env.NITRO_PORT = port.toString();
+    process.env.NITRO_HOST = "0.0.0.0";
+    process.env.NUXT_PUBLIC_VERSION = designerPackageJson.version;
+    process.env.NUXT_PUBLIC_EVENTS_PORT = eventsPort.toString();
+    await new Promise((resolve7) => {
+      console.log = (message) => {
+        if (message.startsWith("Listening on")) {
+          resolve7();
+        }
+      };
+      const serverPath = resolve$1("@highstate/designer/server", packageJsonUrl);
+      void import(serverPath);
+    });
+    console.log = oldConsoleLog;
+    consola.log(
+      [
+        "\n  ",
+        colorize("bold", colorize("cyanBright", "Highstate Designer")),
+        "\n  ",
+        colorize("greenBright", "\u279C Local:  "),
+        colorize("underline", colorize("cyanBright", `http://localhost:${port}`)),
+        "\n"
+      ].join("")
+    );
+    process.on("SIGINT", () => {
+      process.stdout.write("\r");
+      consola.info("shutting down highstate designer...");
+      setTimeout(() => process.exit(0), 1e3);
+    });
+  }
+};
+var InitCommand = class extends Command {
+  static paths = [["init"]];
+  static usage = Command.Usage({
+    description: "Initializes a new Highstate project."
+  });
+  pathOption = Option.String("--path,-p", {
+    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."
+  });
+  platformVersion = Option.String("--platform-version", {
+    description: "The Highstate platform version to use."
+  });
+  stdlibVersion = Option.String("--stdlib-version", {
+    description: "The Highstate standard library version to use."
+  });
+  async execute() {
+    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 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({
+      platformVersion: this.platformVersion,
+      stdlibVersion: this.stdlibVersion
+    });
+    await mkdir(destinationPath, { recursive: true });
+    const isEmptyOrMissing = await isEmptyDirectory(destinationPath);
+    if (!isEmptyOrMissing) {
+      throw new Error(`Destination path is not empty: "${destinationPath}"`);
+    }
+    logger.info("initializing highstate project in %s", destinationPath);
+    await generateFromTemplate(templatePath, destinationPath, {
+      projectName,
+      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);
+    await installDependencies({
+      cwd: destinationPath,
+      packageManager: selectedPackageManager,
+      silent: false
+    });
+    logger.info("project initialized successfully");
+  }
+};
+async function resolveDestinationPath(pathOption, projectName) {
+  if (pathOption) {
+    return resolve(pathOption);
+  }
+  const defaultPath = resolve(process.cwd(), projectName);
+  const pathValue = await input({
+    message: "Project path",
+    default: defaultPath,
+    validate: (value) => value.trim().length > 0 ? true : "Path is required"
+  });
+  return resolve(pathValue);
+}
+async function resolveProjectName(nameOption) {
+  if (nameOption !== void 0) {
+    const trimmed = nameOption.trim();
+    if (trimmed.length === 0) {
+      throw new Error('Flag "--name" must not be empty');
+    }
+    return trimmed;
+  }
+  const value = await input({
+    message: "Project name",
+    default: "my-project",
+    validate: (inputValue) => inputValue.trim().length > 0 ? true : "Name is required"
+  });
+  return value.trim();
+}
+async function resolvePackageManager(packageManagerOption, available) {
+  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 = ["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) {
+  return value === "npm" || value === "pnpm" || value === "yarn";
+}
+async function detectAvailablePackageManagers(candidates) {
+  const results = [];
+  for (const candidate of candidates) {
+    const exists = await isExecutableInPath(candidate);
+    if (exists) {
+      results.push(candidate);
+    }
+  }
+  return results;
+}
+async function isExecutableInPath(command) {
+  const pathValue = process.env.PATH;
+  if (!pathValue) {
+    return false;
+  }
+  const parts = pathValue.split(":").filter(Boolean);
+  for (const part of parts) {
+    const candidate = resolve(part, command);
+    try {
+      await access(candidate);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function isEmptyDirectory(path) {
+  try {
+    const entries = await readdir(path);
+    return entries.length === 0;
+  } catch {
+    return true;
+  }
+}
+function resolveTemplatePath() {
+  const here = fileURLToPath(new URL(import.meta.url));
+  return resolve(here, "..", "..", "assets", "template");
+}
+var PackageCreateCommand = class extends Command {
+  static paths = [["package", "create"]];
+  static usage = Command.Usage({
+    category: "Package",
+    description: "Creates a new package in the workspace."
+  });
+  name = Option.String({ required: true });
+  type = Option.String("--type,-t", {
+    description: "Package type (source, library, worker)"
+  });
+  async execute() {
+    const workspaceRoot = await findWorkspaceRoot();
+    const packageType = highstateConfigSchema.shape.type.parse(this.type);
+    await createPackage(workspaceRoot, this.name, packageType);
+    const packages = await scanWorkspacePackages(workspaceRoot);
+    await updateTsconfigReferences(workspaceRoot, packages);
+    logger.info(`created package: @highstate/${this.name} (${packageType})`);
+  }
+};
+var PackageListCommand = class extends Command {
+  static paths = [["package", "list"]];
+  static usage = Command.Usage({
+    category: "Package",
+    description: "Lists all packages in the workspace with their types."
+  });
+  async execute() {
+    const workspaceRoot = await findWorkspaceRoot();
+    const packages = await scanWorkspacePackages(workspaceRoot);
+    if (packages.length === 0) {
+      logger.info("no packages found in workspace");
+      return;
+    }
+    const table = new Table({
+      columns: [
+        { name: "name", title: "Name" },
+        { name: "type", title: "Type" },
+        { name: "path", title: "Path" }
+      ]
+    });
+    table.addRows(
+      packages.map((pkg) => ({
+        name: pkg.name,
+        type: pkg.type ?? "unknown",
+        path: pkg.relativePath
+      }))
+    );
+    table.printTable();
+  }
+};
+var PackageRemoveCommand = class extends Command {
+  static paths = [["package", "remove"]];
+  static usage = Command.Usage({
+    category: "Package",
+    description: "Removes a package from the workspace."
+  });
+  name = Option.String({ required: true });
+  async execute() {
+    const workspaceRoot = await findWorkspaceRoot();
+    const packages = await scanWorkspacePackages(workspaceRoot);
+    const targetPackage = packages.find(
+      (pkg) => pkg.name === this.name || pkg.name === `@highstate/${this.name}` || pkg.relativePath.endsWith(this.name)
+    );
+    if (!targetPackage) {
+      logger.error(`package not found: ${this.name}`);
+      process.exit(1);
+    }
+    await rm(targetPackage.path, { recursive: true, force: true });
+    const remainingPackages = await scanWorkspacePackages(workspaceRoot);
+    await updateTsconfigReferences(workspaceRoot, remainingPackages);
+    logger.info(`removed package: ${targetPackage.name}`);
+  }
+};
+var PackageUpdateReferencesCommand = class extends Command {
+  static paths = [["package", "update-references"]];
+  static usage = Command.Usage({
+    category: "Package",
+    description: "Updates the root tsconfig.json with references to all packages in the workspace."
+  });
+  async execute() {
+    const workspaceRoot = await findWorkspaceRoot();
+    const packages = await scanWorkspacePackages(workspaceRoot);
+    await updateTsconfigReferences(workspaceRoot, packages, true);
+  }
+};
+var UpdateCommand = class 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() {
+    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 : void 0,
+      stdlibVersion: updateStdlib ? this.stdlibVersion : void 0
+    });
+    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: installDependencies2 } = await import('nypm');
+      logger.info("installing dependencies using %s...", packageManager);
+      await installDependencies2({
+        cwd: projectRoot,
+        packageManager,
+        silent: false
+      });
+    }
+    logger.info("update completed successfully");
+  }
+};
+async function resolveProjectPackageManager(projectRoot) {
+  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) {
+  try {
+    await readFile(`${projectRoot}/package.json`, "utf8");
+  } catch {
+    throw new Error(`File "package.json" not found in "${projectRoot}"`);
+  }
+}
+
+export { BackendIdentityCommand, BackendUnlockMethodAddCommand, BackendUnlockMethodDeleteCommand, BackendUnlockMethodListCommand, BuildCommand, DesignerCommand, InitCommand, PackageCreateCommand, PackageListCommand, PackageRemoveCommand, PackageUpdateReferencesCommand, UpdateCommand };
+//# sourceMappingURL=chunk-VNBLDKUT.js.map
+//# sourceMappingURL=chunk-VNBLDKUT.js.map