@highstate/cli 0.9.16 → 0.9.19

package/dist/main.js

@@ -1,23 +1,30 @@
 #!/usr/bin/env node
-
-// src/main.ts
-import { Builtins, Cli } from "clipanion";
+import { int32ToBytes } from './chunk-CMECLVT7.js';
+import { Command, UsageError, Option, Cli, Builtins } from 'clipanion';
+import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
+import { addDevDependency } from 'nypm';
+import { LogLevels, consola } from 'consola';
+import { colorize } from 'consola/utils';
+import { getPort } from 'get-port-please';
+import { PassThrough } from 'node:stream';
+import pino, { levels } from 'pino';
+import { writeFile, rm, readFile, mkdir, readdir } from 'node:fs/promises';
+import { parseAsync } from 'oxc-parser';
+import { walk } from 'oxc-walker';
+import MagicString from 'magic-string';
+import { resolve, dirname, relative, join } from 'node:path';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { crc32 } from '@aws-crypto/crc32';
+import { resolve as resolve$1 } from 'import-meta-resolve';
+import { z } from 'zod';
+import { existsSync } from 'node:fs';
+import { pipe, mapValues, mapKeys } from 'remeda';
+import { build } from 'tsup';
+import { encode } from '@msgpack/msgpack';
+import { identityToRecipient } from 'age-encryption';
 
 // package.json
-var version = "0.9.15";
-
-// src/commands/designer.ts
-import { Command, UsageError } from "clipanion";
-import { readPackageJSON as readPackageJSON2 } from "pkg-types";
-import { addDevDependency } from "nypm";
-import { consola as consola2 } from "consola";
-import { colorize } from "consola/utils";
-import { getPort } from "get-port-please";
-
-// src/shared/logger.ts
-import { PassThrough } from "node:stream";
-import pino, { levels } from "pino";
-import { consola, LogLevels } from "consola";
+var version = "0.9.18";
 var logger = pino(
   {
     name: "highstate-cli",
@@ -65,7 +72,7 @@ function getBackendServices() {
   if (services) {
     return services;
   }
-  services = import("@highstate/backend").then(({ getSharedServices }) => {
+  services = import('@highstate/backend').then(({ getSharedServices }) => {
     return getSharedServices({
       services: {
         logger: logger.child({}, { msgPrefix: "[backend] " })
@@ -74,12 +81,6 @@ function getBackendServices() {
   });
   return services;
 }
-
-// src/shared/schema-transformer.ts
-import { readFile } from "node:fs/promises";
-import { parseAsync } from "oxc-parser";
-import { walk } from "oxc-walker";
-import MagicString from "magic-string";
 var schemaTransformerPlugin = {
   name: "schema-transformer",
   setup(build2) {
@@ -93,98 +94,164 @@ var schemaTransformerPlugin = {
   }
 };
 async function applySchemaTransformations(content) {
-  const magicString = new MagicString(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 (node.type !== "Property" || node.key.type !== "Identifier") {
-        return;
-      }
-      const parentKey = getParentObjectKey(parentStack) || getMarkerFunctionName(parentStack);
-      if (!parentKey || !["inputs", "outputs", "args", "secrets"].includes(parentKey)) {
-        return;
-      }
-      const jsdoc = comments.find((comment) => isLeadingComment(content, node, comment));
-      if (!jsdoc) {
-        return;
-      }
-      const description = cleanJsdoc(jsdoc.value);
-      const originalValue = content.substring(node.value.start, node.value.end);
-      const entityField = ["inputs", "outputs"].includes(parentKey) ? "entity" : "schema";
-      const isAlreadyStructured = isStructuredValue(originalValue, entityField);
-      if (isAlreadyStructured) {
-        const modifiedValue = injectDescriptionIntoObject(originalValue, description);
-        magicString.update(node.value.start, node.value.end, modifiedValue);
-      } else {
-        magicString.update(
-          node.value.start,
-          node.value.end,
-          `{
-  ${entityField}: ${originalValue},
-  meta: {
-    description: \`${description}\`,
-  },
-}`
-        );
+      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();
     }
   });
-  return magicString.toString();
+  let finalResult = result.toString();
+  if (hasTransformations && !content.includes("__camelCaseToHumanReadable")) {
+    finalResult = 'import { camelCaseToHumanReadable as __camelCaseToHumanReadable } from "@highstate/contract"\n' + finalResult;
+  }
+  return finalResult;
 }
-function injectDescriptionIntoObject(objectString, description) {
-  const trimmed = objectString.trim();
-  const metaRegex = /meta\s*:\s*\{/;
-  if (metaRegex.test(trimmed)) {
-    return trimmed.replace(
-      /meta\s*:\s*\{/,
-      `meta: {
-    description: \`${description}\`,`
-    );
-  } else {
-    const lastBraceIndex = trimmed.lastIndexOf("}");
-    if (lastBraceIndex === -1) {
-      return trimmed;
+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 parentKey = getParentObjectKey(parentStack);
+        if (parentKey && ["inputs", "outputs", "args", "secrets"].includes(parentKey)) {
+          const jsdoc = findLeadingComment(content, node, comments);
+          if (jsdoc) {
+            const description = cleanJsdoc(jsdoc.value);
+            const originalValue = content.substring(
+              propertyNode.value.start,
+              propertyNode.value.end
+            );
+            let helperFunction;
+            if (["args", "secrets"].includes(parentKey)) {
+              helperFunction = "$addArgumentDescription";
+            } else {
+              helperFunction = "$addInputDescription";
+            }
+            const newValue = `${helperFunction}(${originalValue}, \`${description}\`)`;
+            result.update(propertyNode.value.start, propertyNode.value.end, newValue);
+            hasTransformations = true;
+          }
+        }
+      }
+    },
+    leave() {
+      parentStack.pop();
     }
-    const beforeBrace = trimmed.substring(0, lastBraceIndex);
-    const afterBrace = trimmed.substring(lastBraceIndex);
-    const needsComma = beforeBrace.trim().length > 1 && !beforeBrace.trim().endsWith(",");
-    const comma = needsComma ? "," : "";
-    return `${beforeBrace}${comma}
-  meta: {
-    description: \`${description}\`,
-  },
-${afterBrace}`;
+  });
+  let finalResult = result.toString();
+  if (hasTransformations && !content.includes("$addArgumentDescription")) {
+    finalResult = 'import { $addArgumentDescription, $addInputDescription } from "@highstate/contract"\n' + finalResult;
   }
+  return finalResult;
 }
-function isStructuredValue(value, expectedField) {
-  const trimmed = value.trim();
-  if (!trimmed.startsWith("{")) {
-    return false;
-  }
-  const fieldPattern = new RegExp(`^\\s*{[^}]*\\b${expectedField}\\s*:`, "s");
-  return fieldPattern.test(trimmed);
+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 getMarkerFunctionName(parentStack) {
+function findJsdocForDefineFunction(content, parentStack, comments) {
   for (let i = parentStack.length - 1; i >= 0; i--) {
     const node = parentStack[i];
-    if (node.type === "CallExpression" && node.callee.type === "Identifier") {
-      const functionName = node.callee.name;
-      if (functionName.startsWith("$") && ["$args", "$inputs", "$outputs", "$secrets"].includes(functionName)) {
-        return functionName.substring(1);
-      }
+    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 getParentObjectKey(parentStack) {
   for (let i = parentStack.length - 2; i >= 0; i--) {
     const node = parentStack[i];
-    if (node.type === "Property" && node.key.type === "Identifier") {
+    if (node.type === "Property" && "key" in node && node.key.type === "Identifier") {
       return node.key.name;
     }
   }
@@ -200,19 +267,59 @@ function isLeadingComment(content, node, comment) {
 function cleanJsdoc(str) {
   return str.replace(/^\s*\*/gm, "").replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\${/g, "\\${").trim();
 }
-
-// src/shared/source-hash-calculator.ts
-import { dirname, relative, resolve } from "node:path";
-import { readFile as readFile2, writeFile } from "node:fs/promises";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { readPackageJSON, resolvePackageJSON } from "pkg-types";
-import { crc32 } from "@aws-crypto/crc32";
-import { resolve as importMetaResolve } from "import-meta-resolve";
-import { z as z2 } from "zod";
-import { int32ToBytes } from "@highstate/backend/shared";
-
-// src/shared/schemas.ts
-import { z } from "zod";
+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 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"),
@@ -278,7 +385,7 @@ var SourceHashCalculator = class {
       if (singleConfigResult.success) {
         return singleConfigResult.data;
       }
-      const recordConfigResult = z2.record(z2.string(), sourceHashConfigSchema).safeParse(highstateConfig.sourceHash);
+      const recordConfigResult = z.record(z.string(), sourceHashConfigSchema).safeParse(highstateConfig.sourceHash);
       if (recordConfigResult.success && exportKey) {
         const perOutputConfig = recordConfigResult.data[exportKey];
         if (perOutputConfig) {
@@ -322,7 +429,6 @@ var SourceHashCalculator = class {
             })
           );
           break;
-        case "auto":
         default:
           promises.push(
             this.getFileHash(fullPath).then((hash) => ({
@@ -353,7 +459,7 @@ var SourceHashCalculator = class {
     return hash;
   }
   async calculateFileHash(fullPath) {
-    const content = await readFile2(fullPath, "utf8");
+    const content = await readFile(fullPath, "utf8");
     const fileDeps = this.parseDependencies(fullPath, content);
     const hashes = await Promise.all([
       this.hashString(content),
@@ -379,7 +485,7 @@ var SourceHashCalculator = class {
         let resolvedUrl;
         try {
           const baseUrl = pathToFileURL(dirname(this.packageJsonPath));
-          resolvedUrl = importMetaResolve(dependency.package, baseUrl.toString());
+          resolvedUrl = resolve$1(dependency.package, baseUrl.toString());
         } catch (error) {
           this.logger.error(`failed to resolve package "%s"`, dependency.package);
           throw error;
@@ -407,7 +513,7 @@ var SourceHashCalculator = class {
         );
         let manifest;
         try {
-          const manifestContent = await readFile2(highstateManifestPath, "utf8");
+          const manifestContent = await readFile(highstateManifestPath, "utf8");
           manifest = highstateManifestSchema.parse(JSON.parse(manifestContent));
         } catch (error) {
           this.logger.debug(
@@ -455,15 +561,11 @@ var SourceHashCalculator = class {
           id: `npm:${npmPackage}`,
           package: npmPackage
         });
-      } else if (nodeBuiltin) {
-      }
+      } else ;
     }
     return dependencies;
   }
 };
-
-// src/shared/bin-transformer.ts
-import { readFile as readFile3 } from "node:fs/promises";
 function createBinTransformerPlugin(sourceFilePaths) {
   const filter = new RegExp(`(${sourceFilePaths.join("|")})$`);
   logger.debug("created bin transformer plugin with filter: %s", filter);
@@ -471,7 +573,7 @@ function createBinTransformerPlugin(sourceFilePaths) {
     name: "bin-transformer",
     setup(build2) {
       build2.onLoad({ filter }, async (args) => {
-        const content = await readFile3(args.path, "utf-8");
+        const content = await readFile(args.path, "utf-8");
         return {
           contents: `#!/usr/bin/env node
 
@@ -482,6 +584,151 @@ ${content}`,
     }
   };
 }
+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(packagePath, "CHANGELOG.md"),
+    `# Changelog
+
+All notable changes to this project will be documented in this file.
+`,
+    "utf-8"
+  );
+  await writeFile(join(srcPath, "index.ts"), `// ${name} package
+`, "utf-8");
+  return {
+    path: packagePath,
+    relativePath: `packages/${name}`,
+    name: `@highstate/${name}`,
+    type
+  };
+}
 
 // src/commands/designer.ts
 var DesignerCommand = class extends Command {
@@ -491,7 +738,7 @@ var DesignerCommand = class extends Command {
     description: "Starts the Highstate designer in the current project."
   });
   async execute() {
-    const packageJson = await readPackageJSON2();
+    const packageJson = await readPackageJSON();
     if (!packageJson.devDependencies?.["@highstate/cli"]) {
       throw new UsageError(
         "This project is not a Highstate project.\n@highstate/cli must be installed as a devDependency."
@@ -507,17 +754,17 @@ var DesignerCommand = class extends Command {
     const port = await getPort();
     process.env.NITRO_PORT = port.toString();
     process.env.NITRO_HOST = "0.0.0.0";
-    await new Promise((resolve3) => {
+    await new Promise((resolve4) => {
       console.log = (message) => {
         if (message.startsWith("Listening on")) {
-          resolve3();
+          resolve4();
         }
       };
       const path = "@highstate/designer/.output/server/index.mjs";
       void import(path);
     });
     console.log = oldConsoleLog;
-    consola2.log(
+    consola.log(
       [
         "\n  ",
         colorize("bold", colorize("cyanBright", "Highstate Designer")),
@@ -529,23 +776,14 @@ var DesignerCommand = class extends Command {
     );
     process.on("SIGINT", () => {
       process.stdout.write("\r");
-      consola2.info("shutting down highstate designer...");
+      consola.info("shutting down highstate designer...");
       setTimeout(() => process.exit(0), 1e3);
     });
   }
 };
-
-// src/commands/build.ts
-import { resolve as resolve2 } from "node:path";
-import { writeFile as writeFile2 } from "node:fs/promises";
-import { Command as Command2, Option } from "clipanion";
-import { readPackageJSON as readPackageJSON3, resolvePackageJSON as resolvePackageJSON2 } from "pkg-types";
-import { mapKeys, mapValues, pipe } from "remeda";
-import { build } from "tsup";
-import { encode } from "@msgpack/msgpack";
-var BuildCommand = class extends Command2 {
+var BuildCommand = class extends Command {
   static paths = [["build"]];
-  static usage = Command2.Usage({
+  static usage = Command.Usage({
     category: "Builder",
     description: "Builds the Highstate library or unit package."
   });
@@ -554,7 +792,7 @@ var BuildCommand = class extends Command2 {
   silent = Option.Boolean("--silent", true);
   noSourceHash = Option.Boolean("--no-source-hash", false);
   async execute() {
-    const packageJson = await readPackageJSON3();
+    const packageJson = await readPackageJSON();
     const highstateConfig = highstateConfigSchema.parse(packageJson.highstate ?? {});
     if (highstateConfig.type === "library") {
       this.library = true;
@@ -638,10 +876,11 @@ var BuildCommand = class extends Command2 {
       external: ["@pulumi/pulumi"],
       esbuildPlugins,
       treeshake: true,
+      removeNodeProtocol: false,
       silent: this.silent || ["warn", "error", "fatal"].includes(logger.level)
     });
-    const packageJsonPath = await resolvePackageJSON2();
-    const upToDatePackageJson = await readPackageJSON3();
+    const packageJsonPath = await resolvePackageJSON();
+    const upToDatePackageJson = await readPackageJSON();
     if (!this.noSourceHash) {
       const sourceHashCalculator = new SourceHashCalculator(
         packageJsonPath,
@@ -655,35 +894,113 @@ var BuildCommand = class extends Command2 {
       await sourceHashCalculator.writeHighstateManifest("./dist", distPathToExportKey);
     }
     if (this.library) {
-      const { loadLibrary } = await import("./library-loader-CGEPTS4L.js");
-      const fullModulePaths = Object.values(entry).map((value) => resolve2(value.distPath));
+      const { loadLibrary } = await import('./library-loader-6TJTW2HX.js');
+      const fullModulePaths = Object.values(entry).map((value) => resolve(value.distPath));
       logger.info("evaluating library components from modules: %s", fullModulePaths.join(", "));
       const library = await loadLibrary(logger, fullModulePaths);
-      const libraryPath = resolve2("./dist", "highstate.library.msgpack");
-      await writeFile2(libraryPath, encode(library), "utf8");
+      const libraryPath = resolve("./dist", "highstate.library.msgpack");
+      await writeFile(libraryPath, encode(library), "utf8");
     }
     logger.info("build completed successfully");
   }
 };
-
-// src/commands/backend/identity.ts
-import { Command as Command3 } from "clipanion";
-import { identityToRecipient } from "age-encryption";
-var BackendIdentityCommand = class extends Command3 {
+var BackendIdentityCommand = class extends Command {
   static paths = [["backend", "identity"]];
-  static usage = Command3.Usage({
+  static usage = Command.Usage({
     category: "Backend",
     description: "Ensures the backend identity is set up and returns the recipient."
   });
   async execute() {
     const backendLogger = logger.child({}, { msgPrefix: "[backend] " });
-    const { getOrCreateBackendIdentity } = await import("@highstate/backend");
+    const { getOrCreateBackendIdentity } = await import('@highstate/backend');
     const backendIdentity = await getOrCreateBackendIdentity(backendLogger);
     const recipient = await identityToRecipient(backendIdentity);
     logger.info(`stored backend identity is: ${recipient}`);
     logger.info(`run "highstate backend unlock-method add ${recipient}" on other authorized device`);
   }
 };
+var UpdateReferencesCommand = 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 ListCommand = 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) {
+      console.log("No packages found in workspace.");
+      return;
+    }
+    const nameWidth = Math.max(4, ...packages.map((pkg) => pkg.name.length));
+    const typeWidth = Math.max(4, ...packages.map((pkg) => pkg.type?.length ?? 0));
+    const pathWidth = Math.max(4, ...packages.map((pkg) => pkg.relativePath.length));
+    console.log(
+      `${"Name".padEnd(nameWidth)} ${"Type".padEnd(typeWidth)} ${"Path".padEnd(pathWidth)}`
+    );
+    console.log(`${"-".repeat(nameWidth)} ${"-".repeat(typeWidth)} ${"-".repeat(pathWidth)}`);
+    for (const pkg of packages) {
+      const type = pkg.type ?? "unknown";
+      console.log(
+        `${pkg.name.padEnd(nameWidth)} ${type.padEnd(typeWidth)} ${pkg.relativePath.padEnd(pathWidth)}`
+      );
+    }
+  }
+};
+var CreateCommand = 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);
+    console.log(`Created package: @highstate/${this.name} (${packageType})`);
+  }
+};
+var RemoveCommand = 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) {
+      console.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);
+    console.log(`Removed package: ${targetPackage.name}`);
+  }
+};
 
 // src/main.ts
 var cli = new Cli({
@@ -694,7 +1011,12 @@ var cli = new Cli({
 cli.register(BuildCommand);
 cli.register(DesignerCommand);
 cli.register(BackendIdentityCommand);
+cli.register(UpdateReferencesCommand);
+cli.register(ListCommand);
+cli.register(CreateCommand);
+cli.register(RemoveCommand);
 cli.register(Builtins.HelpCommand);
 cli.register(Builtins.VersionCommand);
 await cli.runExit(process.argv.slice(2));
+//# sourceMappingURL=main.js.map
 //# sourceMappingURL=main.js.map