@highstate/cli 0.14.0 → 0.14.1

package/assets/template/.yarnrc.tpl.yml

@@ -0,0 +1,3 @@
+{{#if isYarn}}
+nodeLinker: node-modules
+{{/if}}

package/assets/template/package.tpl.json

@@ -0,0 +1,22 @@
+{
+  "name": "{{packageName}}",
+  "private": true,
+  {{#if isYarn}}
+  "packageManager": "yarn@4.12.0",
+  {{/if}}
+  {{#if isPnpm}}
+  "packageManager": "pnpm@10.26.1",
+  {{/if}}
+  {{#unless isPnpm}}
+  "workspaces": ["packages/*"],
+  {{/unless}}
+  "dependencies": {
+    "@highstate/contract": "{{platformVersion}}",
+    "@highstate/pulumi": "{{platformVersion}}",
+    "@highstate/library": "{{libraryVersion}}"
+  },
+  "devDependencies": {
+    "@highstate/cli": "{{platformVersion}}",
+    "typescript": "^5.9.3"
+  }
+}

package/assets/template/packages/library/package.tpl.json

@@ -0,0 +1,14 @@
+{
+  "name": "@{{projectName}}/library",
+  "private": true,
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@highstate/contract": "*",
+    "@highstate/library": "*"
+  }
+}

package/assets/template/packages/library/src/index.ts

@@ -0,0 +1,8 @@
+// In this package you can define your custom components and units.
+// The structure is up to you.
+// See: https://highstate.io/fundamentals/components
+// Also see standard library package for inspiration:
+// https://github.com/highstate-io/highstate/tree/main/packages/standard/library
+
+export * from "./my-component"
+export * from "./my-unit"

package/assets/template/packages/library/src/my-component.ts

@@ -0,0 +1,27 @@
+import { defineComponent } from "@highstate/contract"
+import { common } from "@highstate/library"
+
+export const myComponent = defineComponent({
+  type: "{{projectName}}.my-component.v0",
+
+  inputs: {
+    server: common.serverEntity,
+  },
+
+  outputs: {
+    server: common.serverEntity,
+  },
+
+  create({ name, inputs }) {
+    const { server } = common.script({
+      name,
+      inputs,
+
+      args: {
+        script: "echo 'Hello, Highstate!'",
+      },
+    })
+
+    return { server }
+  },
+})

package/assets/template/packages/library/src/my-unit.ts

@@ -0,0 +1,23 @@
+import { defineUnit, z } from "@highstate/contract"
+import { common } from "@highstate/library"
+
+export const myUnit = defineUnit({
+  type: "{{projectName}}.my-unit.v0",
+
+  args: {
+    message: z.string().default("Hello from my-unit!"),
+  },
+
+  inputs: {
+    server: common.serverEntity,
+  },
+
+  outputs: {
+    server: common.serverEntity,
+  },
+
+  source: {
+    package: "@{{projectName}}/units",
+    path: "my-unit",
+  },
+})

package/assets/template/packages/library/tsconfig.tpl.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.base.json",
+}

package/assets/template/packages/units/package.tpl.json

@@ -0,0 +1,15 @@
+{
+  "name": "@{{projectName}}/units",
+  "private": true,
+  "dependencies": {
+    "@{{projectName}}/library": "workspace:*"
+  },
+  "exports":{
+    "./my-unit": "./dist/my-unit/index.js"
+  },
+  "peerDependencies": {
+    "@highstate/contract": "*",
+    "@highstate/pulumi": "*",
+    "@pulumi/pulumi": "*"
+  }
+}

package/assets/template/packages/units/src/my-unit/index.ts

@@ -0,0 +1,11 @@
+import { myUnit } from "@{{projectName}}/library"
+import { forUnit } from "@highstate/pulumi"
+
+const { inputs, outputs } = forUnit(myUnit)
+
+// In this program you can implement the logic of your custom unit using Pulumi SDK.
+// See: https://highstate.io/fundamentals/units
+
+export default outputs({
+  server: inputs.server,
+})

package/assets/template/packages/units/tsconfig.tpl.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.base.json",
+}

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

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

package/assets/template/tsconfig.base.tpl.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./node_modules/@highstate/cli/assets/tsconfig.base.json",
+}

package/dist/highstate.manifest.json

@@ -1,5 +1,5 @@
 {
   "sourceHashes": {
-    "./dist/main.js": 3586364367
+    "./dist/main.js": 4001946629
   }
 }

package/dist/main.js

@@ -4,31 +4,32 @@ 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, rm, readFile, mkdir, readdir } from 'node:fs/promises';
+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 { resolve, relative, dirname, 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 { readPackageJSON, resolvePackageJSON } from 'pkg-types';
 import { existsSync } from 'node:fs';
-import { input, confirm } from '@inquirer/prompts';
+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 } from 'nypm';
+import { addDevDependency, installDependencies } from 'nypm';
 
 // package.json
-var version = "0.13.2";
+var version = "0.14.0";
 var logger = pino(
   {
     name: "highstate-cli",
@@ -172,6 +173,49 @@ function extractEntryPoints(packageJson) {
   }
   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) {
@@ -489,8 +533,8 @@ var SourceHashCalculator = class {
   /**
    * Calculates CRC32 hash of a string.
    */
-  hashString(input2) {
-    return crc32(Buffer.from(input2));
+  hashString(input3) {
+    return crc32(Buffer.from(input3));
   }
   /**
    * Gets the highstate configuration from package.json with defaults.
@@ -1075,10 +1119,10 @@ var DesignerCommand = class extends Command {
     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((resolve4) => {
+    await new Promise((resolve6) => {
       console.log = (message) => {
         if (message.startsWith("Listening on")) {
-          resolve4();
+          resolve6();
         }
       };
       const serverPath = resolve$1("@highstate/designer/server", packageJsonUrl);
@@ -1102,6 +1146,140 @@ var DesignerCommand = class extends Command {
     });
   }
 };
+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({
@@ -1195,6 +1373,7 @@ var cli = new Cli({
 });
 cli.register(BuildCommand);
 cli.register(DesignerCommand);
+cli.register(InitCommand);
 cli.register(BackendIdentityCommand);
 cli.register(BackendUnlockMethodListCommand);
 cli.register(BackendUnlockMethodAddCommand);