@highstate/cli 0.15.0 → 0.16.0

package/dist/main.js

@@ -1,1387 +1,25 @@
 #!/usr/bin/env node
-import { int32ToBytes } from './chunk-CMECLVT7.js';
-import { Command, Option, UsageError, Cli, Builtins } from 'clipanion';
-import { hostname } from 'node:os';
-import { loadConfig } from '@highstate/backend';
-import { identityToRecipient } from 'age-encryption';
-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, basename, relative, dirname, join } from 'node:path';
-import Handlebars from 'handlebars';
-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 { readPackageJSON, resolvePackageJSON } from 'pkg-types';
-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, installDependencies } from 'nypm';
+import { BuildCommand, DesignerCommand, InitCommand, UpdateCommand, BackendIdentityCommand, BackendUnlockMethodListCommand, BackendUnlockMethodAddCommand, BackendUnlockMethodDeleteCommand, PackageUpdateReferencesCommand, PackageListCommand, PackageCreateCommand, PackageRemoveCommand } from './chunk-VNBLDKUT.js';
+import './chunk-CMECLVT7.js';
+import { Cli, Builtins } from 'clipanion';
 
-// package.json
-var version = "0.14.1";
-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`);
-      }
-      if (!distPath.startsWith("./dist/")) {
-        throw new Error(
-          `The default value of export "${key}" must start with "./dist/" in package.json, got "${distPath}"`
-        );
-      }
-      if (!distPath.endsWith(".js")) {
-        throw new Error(
-          `The default value of export "${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: 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);
-}
-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;
-  }
-};
-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"]);
-    }
-    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((resolve6) => {
-      console.log = (message) => {
-        if (message.startsWith("Listening on")) {
-          resolve6();
-        }
-      };
-      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 _InitCommand 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."
-  });
-  static defaultPlatformVersion = "0.14.0";
-  static defaultLibraryVersion = "0.14.0";
-  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 destinationPath = await resolveDestinationPath(this.pathOption);
-    const defaultName = basename(destinationPath);
-    const projectName = await resolveProjectName(this.name, defaultName);
-    const selectedPackageManager = await resolvePackageManager(
-      this.packageManager,
-      availablePackageManagers
-    );
-    const templatePath = resolveTemplatePath();
-    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: _InitCommand.defaultPlatformVersion,
-      libraryVersion: _InitCommand.defaultLibraryVersion,
-      isPnpm: selectedPackageManager === "pnpm" ? "true" : "",
-      isYarn: selectedPackageManager === "yarn" ? "true" : ""
-    });
-    logger.info("installing dependencies using %s...", selectedPackageManager);
-    await installDependencies({
-      cwd: destinationPath,
-      packageManager: selectedPackageManager,
-      silent: false
-    });
-    logger.info("project initialized successfully");
-  }
-};
-async function resolveDestinationPath(pathOption) {
-  if (pathOption) {
-    return resolve(pathOption);
-  }
-  const pathValue = await input({
-    message: "Project path",
-    default: ".",
-    validate: (value) => value.trim().length > 0 ? true : "Path is required"
-  });
-  return resolve(pathValue);
-}
-async function resolveProjectName(nameOption, defaultName) {
-  if (nameOption) {
-    return nameOption.trim();
-  }
-  const value = await input({
-    message: "Project name",
-    default: defaultName,
-    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 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);
-    logger.info(`created package: @highstate/${this.name} (${packageType})`);
-  }
-};
-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) {
-      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 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) {
-      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 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);
-  }
-};
-
-// src/main.ts
 var cli = new Cli({
   binaryName: "highstate",
-  binaryLabel: "Highstate",
-  binaryVersion: version
+  binaryLabel: "Highstate"
+  // binaryVersion: version,
 });
 cli.register(BuildCommand);
 cli.register(DesignerCommand);
 cli.register(InitCommand);
+cli.register(UpdateCommand);
 cli.register(BackendIdentityCommand);
 cli.register(BackendUnlockMethodListCommand);
 cli.register(BackendUnlockMethodAddCommand);
 cli.register(BackendUnlockMethodDeleteCommand);
-cli.register(UpdateReferencesCommand);
-cli.register(ListCommand);
-cli.register(CreateCommand);
-cli.register(RemoveCommand);
+cli.register(PackageUpdateReferencesCommand);
+cli.register(PackageListCommand);
+cli.register(PackageCreateCommand);
+cli.register(PackageRemoveCommand);
 cli.register(Builtins.HelpCommand);
 cli.register(Builtins.VersionCommand);
 await cli.runExit(process.argv.slice(2));