@powerhousedao/ph-cli 0.30.0 → 0.31.0

package/dist/chunk-27FF7J6K.js

@@ -0,0 +1,45 @@
+// src/commands/connect.ts
+import {
+  startConnectStudio
+} from "@powerhousedao/connect";
+import { getConfig } from "@powerhousedao/config/powerhouse";
+async function startConnect(connectOptions) {
+  const { documentModelsDir, editorsDir } = getConfig();
+  const options = { documentModelsDir, editorsDir, ...connectOptions };
+  return await startConnectStudio(options);
+}
+function connectCommand(program) {
+  program.command("connect").description("Starts Connect Studio").option("-p, --port <port>", "Port to run the server on", "3000").option("-h, --host", "Expose the server to the network").option("--https", "Enable HTTPS").option("--open", "Open the browser").option(
+    "--config-file <configFile>",
+    "Path to the powerhouse.config.js file"
+  ).option(
+    "-le, --local-editors <localEditors>",
+    "Link local document editors path"
+  ).option(
+    "-ld, --local-documents <localDocuments>",
+    "Link local documents path"
+  ).action(async (...args) => {
+    const connectOptions = args.at(0) || {};
+    const { documentModelsDir, editorsDir, packages, studio } = getConfig();
+    await startConnectStudio({
+      port: studio?.port?.toString() || void 0,
+      packages,
+      localDocuments: documentModelsDir || void 0,
+      localEditors: editorsDir || void 0,
+      open: studio?.openBrowser,
+      ...connectOptions
+    });
+  });
+}
+if (process.argv.at(2) === "spawn") {
+  const optionsArg = process.argv.at(3);
+  const options = optionsArg ? JSON.parse(optionsArg) : {};
+  startConnect(options).catch((e) => {
+    throw e;
+  });
+}
+
+export {
+  startConnect,
+  connectCommand
+};

package/dist/chunk-6O6TUXJK.js

@@ -0,0 +1,90 @@
+// src/commands/switchboard.ts
+import { generateFromFile } from "@powerhousedao/codegen";
+import { getConfig } from "@powerhousedao/config/powerhouse";
+import {
+  DefaultStartServerOptions,
+  startServer
+} from "@powerhousedao/reactor-local";
+var DefaultSwitchboardOptions = {
+  ...DefaultStartServerOptions,
+  dev: true
+};
+async function startLocalSwitchboard(switchboardOptions) {
+  const baseConfig = getConfig(switchboardOptions.configFile);
+  const options = {
+    ...DefaultSwitchboardOptions,
+    ...switchboardOptions
+  };
+  const https = switchboardOptions.httpsKeyFile && switchboardOptions.httpsCertFile ? {
+    keyPath: switchboardOptions.httpsKeyFile,
+    certPath: switchboardOptions.httpsCertFile
+  } : void 0;
+  const reactor = await startServer({ ...options, https });
+  if (options.generate) {
+    await addGenerateTransmitter(reactor, baseConfig);
+  }
+  return reactor;
+}
+async function addGenerateTransmitter(reactor, config) {
+  return reactor.addListener(
+    "powerhouse",
+    {
+      onStrands: async function(strands) {
+        const documentPaths = /* @__PURE__ */ new Set();
+        for (const strand of strands) {
+          documentPaths.add(
+            reactor.getDocumentPath(strand.driveId, strand.documentId)
+          );
+        }
+        for (const path of documentPaths) {
+          await generateFromFile(path, config);
+        }
+        return Promise.resolve();
+      },
+      onDisconnect: () => Promise.resolve()
+    },
+    {
+      filter: {
+        documentType: ["powerhouse/document-model"],
+        scope: ["global"],
+        branch: ["*"],
+        documentId: ["*"]
+      },
+      block: false,
+      listenerId: "reactor-local-document-model-generator",
+      label: "reactor-local-document-model-generator"
+    }
+  );
+}
+var switchboard = (options) => {
+  return startLocalSwitchboard(options);
+};
+function reactorCommand(program) {
+  program.command("switchboard").alias("reactor").description("Starts local switchboard").option("--port <PORT>", "port to host the api", "4001").option(
+    "--config-file <configFile>",
+    "Path to the powerhouse.config.js file"
+  ).option("--generate", "generate code when document model is updated").option("--db-path <DB_PATH>", "path to the database").option("--https-key-file <HTTPS_KEY_FILE>", "path to the ssl key file").option("--https-cert-file <HTTPS_CERT_FILE>", "path to the ssl cert file").option(
+    "-w, --watch",
+    "if the reactor should watch for local changes to document models and processors"
+  ).option(
+    "--packages <packages...>",
+    "list of packages to be loaded, if defined then packages on config file are ignored"
+  ).action(async (...args) => {
+    await switchboard(...args);
+  });
+}
+if (process.argv.at(2) === "spawn") {
+  const optionsArg = process.argv.at(3);
+  const options = optionsArg ? JSON.parse(optionsArg) : {};
+  startLocalSwitchboard(options).then((switchboard2) => {
+    process.send?.(`driveUrl:${switchboard2.driveUrl}`);
+  }).catch((e) => {
+    throw e;
+  });
+}
+
+export {
+  DefaultSwitchboardOptions,
+  switchboard,
+  reactorCommand
+};

package/dist/chunk-CWUXPR5K.js

@@ -0,0 +1,109 @@
+import {
+  DefaultSwitchboardOptions
+} from "./chunk-6O6TUXJK.js";
+
+// src/commands/dev.ts
+import { blue, green, red } from "colorette";
+import { fork } from "node:child_process";
+import path, { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+var __dirname = import.meta.dirname || dirname(fileURLToPath(import.meta.url));
+function spawnLocalSwitchboard(options) {
+  const child = fork(
+    path.join(__dirname, "switchboard.js"),
+    ["spawn", JSON.stringify(options)],
+    { silent: true }
+  );
+  return new Promise((resolve) => {
+    child.on("message", (message) => {
+      const text = message.toString();
+      if (text.startsWith("driveUrl:")) {
+        const driveUrl = text.substring("driveUrl:".length);
+        resolve({ driveUrl });
+      }
+    });
+    child.stdout.on("data", (data) => {
+      const message = data.toString();
+      const lines = message.split("\n").filter((line) => line.trim().length);
+      for (const line of lines) {
+        process.stdout.write(blue(`[Switchboard]: ${line}
+`));
+      }
+    });
+    child.stderr.on("error", (data) => {
+      process.stderr.write(red(`[Switchboard]: ${data.toString()}`));
+    });
+    child.on("error", (err) => {
+      process.stderr.write(red(`[Switchboard]: ${err}`));
+    });
+    child.on("exit", (code) => {
+      console.log(`Switchboard process exited with code ${code}`);
+    });
+  });
+}
+async function spawnConnect(options, localReactorUrl) {
+  const child = fork(
+    path.join(__dirname, "connect.js"),
+    ["spawn", JSON.stringify(options ?? {})],
+    {
+      silent: true,
+      env: {
+        ...process.env,
+        // TODO add studio variables?
+        LOCAL_DOCUMENT_MODELS: options?.localDocuments,
+        LOCAL_DOCUMENT_EDITORS: options?.localEditors,
+        PH_CONNECT_DEFAULT_DRIVES_URL: localReactorUrl
+      }
+    }
+  );
+  return new Promise((resolve) => {
+    child.stdout.on("data", (data) => {
+      resolve();
+      process.stdout.write(green(`[Connect]: ${data.toString()}`));
+    });
+    child.stderr.on("data", (data) => {
+      process.stderr.write(red(`[Connect]: ${data.toString()}`));
+    });
+    child.on("close", (code) => {
+      console.log(`Connect process exited with code ${code}`);
+    });
+  });
+}
+var dev = async ({
+  generate,
+  watch,
+  switchboardPort = DefaultSwitchboardOptions.port,
+  configFile,
+  httpsKeyFile,
+  httpsCertFile
+}) => {
+  try {
+    const https = httpsKeyFile && httpsCertFile ? {
+      keyPath: httpsKeyFile,
+      certPath: httpsCertFile
+    } : void 0;
+    const { driveUrl } = await spawnLocalSwitchboard({
+      generate,
+      port: switchboardPort,
+      watch,
+      https
+    });
+    await spawnConnect({ configFile }, driveUrl);
+  } catch (error) {
+    console.error(error);
+  }
+};
+function devCommand(program) {
+  program.command("dev").description("Starts dev environment").option("--generate", "generate code when document model is updated").option("--switchboard-port <port>", "port to use for the switchboard").option("--https-key-file <HTTPS_KEY_FILE>", "path to the ssl key file").option("--https-cert-file <HTTPS_CERT_FILE>", "path to the ssl cert file").option(
+    "--config-file <configFile>",
+    "Path to the powerhouse.config.js file"
+  ).option(
+    "-w, --watch",
+    "if the switchboard should watch for local changes to document models and processors"
+  ).action(dev);
+}
+
+export {
+  dev,
+  devCommand
+};

package/dist/chunk-E3EWRF5U.js

@@ -0,0 +1,97 @@
+import {
+  SUPPORTED_PACKAGE_MANAGERS,
+  getPackageManagerFromLockfile,
+  getProjectInfo,
+  packageManagers,
+  updateConfigFile
+} from "./chunk-FDMMJENR.js";
+
+// src/commands/install.ts
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+function installDependency(packageManager, dependencies, projectPath, workspace) {
+  if (!fs.existsSync(projectPath)) {
+    throw new Error(`Project path not found: ${projectPath}`);
+  }
+  const manager = packageManagers[packageManager];
+  let installCommand2 = manager.installCommand.replace(
+    "{{dependency}}",
+    dependencies.join(" ")
+  );
+  if (workspace) {
+    installCommand2 += ` ${manager.workspaceOption}`;
+  }
+  const commandOptions = { cwd: projectPath };
+  execSync(installCommand2, {
+    stdio: "inherit",
+    ...commandOptions
+  });
+}
+var install = (dependencies, options) => {
+  if (options.debug) {
+    console.log(">>> command arguments", { dependencies, options });
+  }
+  if (!dependencies || dependencies.length === 0) {
+    throw new Error("\u274C Dependency name is required");
+  }
+  if (options.packageManager && !SUPPORTED_PACKAGE_MANAGERS.includes(options.packageManager)) {
+    throw new Error(
+      "\u274C Unsupported package manager. Supported package managers: npm, yarn, pnpm, bun"
+    );
+  }
+  const projectInfo = getProjectInfo(options.debug);
+  if (options.debug) {
+    console.log("\n>>> projectInfo", projectInfo);
+  }
+  const isGlobal = options.global || projectInfo.isGlobal;
+  const packageManager = options.packageManager || getPackageManagerFromLockfile(projectInfo.path);
+  if (options.debug) {
+    console.log("\n>>> installDependency arguments:");
+    console.log(">>> packageManager", packageManager);
+    console.log(">>> dependencies", dependencies);
+    console.log(">>> isGlobal", isGlobal);
+    console.log(">>> projectPath", projectInfo.path);
+    console.log(">>> workspace", options.workspace);
+  }
+  try {
+    console.log("installing dependencies \u{1F4E6} ...");
+    installDependency(
+      packageManager,
+      dependencies,
+      projectInfo.path,
+      options.workspace
+    );
+    console.log("Dependency installed successfully \u{1F389}");
+  } catch (error) {
+    console.error("\u274C Failed to install dependencies");
+    throw error;
+  }
+  if (options.debug) {
+    console.log("\n>>> updateConfigFile arguments:");
+    console.log(">>> dependencies", dependencies);
+    console.log(">>> projectPath", projectInfo.path);
+  }
+  try {
+    console.log("\u2699\uFE0F Updating powerhouse config file...");
+    updateConfigFile(dependencies, projectInfo.path, "install");
+    console.log("Config file updated successfully \u{1F389}");
+  } catch (error) {
+    console.error("\u274C Failed to update config file");
+    throw error;
+  }
+};
+function installCommand(program) {
+  program.command("install").alias("add").alias("i").description("Install a powerhouse dependency").argument("[dependencies...]", "Names of the dependencies to install").option("-g, --global", "Install the dependency globally").option("--debug", "Show additional logs").option(
+    "-w, --workspace",
+    "Install the dependency in the workspace (use this option for monorepos)"
+  ).option(
+    "--package-manager <packageManager>",
+    "force package manager to use"
+  ).action(install);
+}
+
+export {
+  installDependency,
+  install,
+  installCommand
+};

package/dist/chunk-FDMMJENR.js

@@ -0,0 +1,132 @@
+// src/utils.ts
+import path, { dirname } from "node:path";
+import fs from "node:fs";
+import { homedir } from "node:os";
+import { getConfig } from "@powerhousedao/config/powerhouse";
+var POWERHOUSE_CONFIG_FILE = "powerhouse.config.json";
+var POWERHOUSE_GLOBAL_DIR = path.join(homedir(), ".ph");
+var SUPPORTED_PACKAGE_MANAGERS = ["npm", "yarn", "pnpm", "bun"];
+var packageManagers = {
+  bun: {
+    globalPathRegexp: /[\\/].bun[\\/]/,
+    installCommand: "bun add {{dependency}}",
+    uninstallCommand: "bun remove {{dependency}}",
+    workspaceOption: "",
+    lockfile: "bun.lock"
+  },
+  pnpm: {
+    globalPathRegexp: /[\\/]pnpm[\\/]/,
+    installCommand: "pnpm add {{dependency}}",
+    uninstallCommand: "pnpm remove {{dependency}}",
+    workspaceOption: "--workspace-root",
+    lockfile: "pnpm-lock.yaml"
+  },
+  yarn: {
+    globalPathRegexp: /[\\/]yarn[\\/]/,
+    installCommand: "yarn add {{dependency}}",
+    uninstallCommand: "yarn remove {{dependency}}",
+    workspaceOption: "-W",
+    lockfile: "yarn.lock"
+  },
+  npm: {
+    installCommand: "npm install {{dependency}}",
+    uninstallCommand: "npm uninstall {{dependency}}",
+    workspaceOption: "",
+    lockfile: "package-lock.json"
+  }
+};
+function defaultPathValidation() {
+  return true;
+}
+function isPowerhouseProject(dir) {
+  const powerhouseConfigPath = path.join(dir, POWERHOUSE_CONFIG_FILE);
+  return fs.existsSync(powerhouseConfigPath);
+}
+function findNodeProjectRoot(dir, pathValidation = defaultPathValidation) {
+  const packageJsonPath = path.join(dir, "package.json");
+  if (fs.existsSync(packageJsonPath) && pathValidation(dir)) {
+    return dir;
+  }
+  const parentDir = dirname(dir);
+  if (parentDir === dir) {
+    return null;
+  }
+  return findNodeProjectRoot(parentDir, pathValidation);
+}
+function getProjectInfo(debug) {
+  const currentPath = process.cwd();
+  if (debug) {
+    console.log(">>> currentPath", currentPath);
+  }
+  const projectPath = findNodeProjectRoot(currentPath, isPowerhouseProject);
+  if (!projectPath) {
+    return {
+      isGlobal: true,
+      path: POWERHOUSE_GLOBAL_DIR
+    };
+  }
+  return {
+    isGlobal: false,
+    path: projectPath
+  };
+}
+function getPackageManagerFromLockfile(dir) {
+  if (fs.existsSync(path.join(dir, packageManagers.pnpm.lockfile))) {
+    return "pnpm";
+  } else if (fs.existsSync(path.join(dir, packageManagers.yarn.lockfile))) {
+    return "yarn";
+  } else if (fs.existsSync(path.join(dir, packageManagers.bun.lockfile))) {
+    return "bun";
+  }
+  return "npm";
+}
+function getPackageManagerFromPath(dir) {
+  const lowerCasePath = dir.toLowerCase();
+  if (packageManagers.bun.globalPathRegexp.test(lowerCasePath)) {
+    return "bun";
+  } else if (packageManagers.pnpm.globalPathRegexp.test(lowerCasePath)) {
+    return "pnpm";
+  } else if (packageManagers.yarn.globalPathRegexp.test(lowerCasePath)) {
+    return "yarn";
+  }
+  return "npm";
+}
+function updateConfigFile(dependencies, projectPath, task = "install") {
+  const configPath = path.join(projectPath, POWERHOUSE_CONFIG_FILE);
+  const isInstall = task === "install";
+  if (!fs.existsSync(configPath)) {
+    throw new Error(
+      `powerhouse.config.json file not found. projectPath: ${projectPath}`
+    );
+  }
+  const config = JSON.parse(
+    fs.readFileSync(configPath, "utf-8")
+  );
+  const mappedPackages = dependencies.map(
+    (dep) => ({
+      packageName: dep
+    })
+  );
+  const updatedConfig = {
+    ...config,
+    packages: isInstall ? [...config.packages || [], ...mappedPackages] : [...config.packages || []].filter(
+      (pkg) => !dependencies.includes(pkg.packageName)
+    )
+  };
+  fs.writeFileSync(configPath, JSON.stringify(updatedConfig, null, 2));
+}
+
+export {
+  POWERHOUSE_CONFIG_FILE,
+  POWERHOUSE_GLOBAL_DIR,
+  SUPPORTED_PACKAGE_MANAGERS,
+  packageManagers,
+  defaultPathValidation,
+  isPowerhouseProject,
+  findNodeProjectRoot,
+  getProjectInfo,
+  getPackageManagerFromLockfile,
+  getPackageManagerFromPath,
+  updateConfigFile,
+  getConfig
+};

package/dist/chunk-KPMNRIJU.js

@@ -0,0 +1,10 @@
+// src/commands/help.ts
+function helpCommand(program) {
+  program.command("help").description("Display help information").action(() => {
+    program.help();
+  });
+}
+
+export {
+  helpCommand
+};

package/dist/chunk-OH5NZOCQ.js

@@ -0,0 +1,85 @@
+// src/commands/generate.ts
+import {
+  generate as generateCode,
+  generateEditor,
+  generateFromFile,
+  generateImportScript,
+  generateProcessor,
+  generateSubgraph,
+  promptDirectories
+} from "@powerhousedao/codegen";
+import { getConfig } from "@powerhousedao/config/powerhouse";
+var generate = async (filePath, options) => {
+  const baseConfig = getConfig();
+  const config = {
+    ...baseConfig,
+    ...{
+      ...options.editors && { editorsDir: options.editors },
+      ...options.processors && { processorsDir: options.processors },
+      ...options.documentModels && {
+        documentModelsDir: options.documentModels
+      },
+      ...options.skipFormat && { skipFormat: options.skipFormat },
+      ...options.interactive && { interactive: options.interactive },
+      ...options.watch && { watch: options.watch }
+    }
+  };
+  const command = {
+    editor: !!options.editor,
+    editorName: options.editor,
+    documentTypes: options.documentTypes,
+    processor: !!options.processor,
+    processorName: options.processor,
+    processorType: options.processorType,
+    subgraph: !!options.subgraph,
+    subgraphName: options.subgraph,
+    importScript: !!options.importScript,
+    importScriptName: options.importScript
+  };
+  if (config.interactive) {
+    const result = await promptDirectories(config);
+    Object.assign(config, result);
+  }
+  if (command.editor) {
+    if (!command.editorName) {
+      throw new Error("Editor name is required (--editor or -e)");
+    }
+    await generateEditor(
+      command.editorName,
+      command.documentTypes?.split(/[|,;]/g) ?? [],
+      config
+    );
+    return;
+  }
+  if (command.processor && options.processor) {
+    const processorType = options.processorType === "operational" ? "operational" : "analytics";
+    await generateProcessor(
+      options.processor,
+      processorType,
+      options.documentTypes?.split(",") ?? [],
+      config
+    );
+    return;
+  }
+  if (command.subgraph && command.subgraphName) {
+    await generateSubgraph(command.subgraphName, config);
+    return;
+  }
+  if (command.importScript && command.importScriptName) {
+    await generateImportScript(command.importScriptName, config);
+    return;
+  }
+  if (filePath) {
+    await generateFromFile(filePath, config);
+    return;
+  }
+  await generateCode(config);
+};
+function generateCommand(program) {
+  program.command("generate").description("Generate code from the document models").argument("[document-model-file]", "Path to the document model file").option("-i, --interactive", "Run the command in interactive mode").option("--editors <type>", "Path to the editors directory").option("-e, --editor <type>", "Editor Name").option("--processors <type>", "Path to the processors directory").option("-p, --processor <type>", "Processor Name").option("--processor-type <type>", "Processor Type").option("-s, --subgraph <type>", "Subgraph Name").option("--document-models <type>", "Path to the document models directory").option("--document-types <type>", "Supported document types by the editor").option("-is, --import-script <type>", "Import Script Name").option("-sf, --skip-format", "Skip formatting the generated code").option("-w, --watch", "Watch the generated code").action(generate);
+}
+
+export {
+  generate,
+  generateCommand
+};

package/dist/chunk-PUQARXW2.js

@@ -0,0 +1,44 @@
+import {
+  installCommand
+} from "./chunk-E3EWRF5U.js";
+import {
+  serviceCommand
+} from "./chunk-ZN4M6TJ2.js";
+import {
+  uninstallCommand
+} from "./chunk-X2RNXISI.js";
+import {
+  connectCommand
+} from "./chunk-27FF7J6K.js";
+import {
+  devCommand
+} from "./chunk-CWUXPR5K.js";
+import {
+  reactorCommand
+} from "./chunk-6O6TUXJK.js";
+import {
+  generateCommand
+} from "./chunk-OH5NZOCQ.js";
+import {
+  helpCommand
+} from "./chunk-KPMNRIJU.js";
+
+// src/commands/index.ts
+var commands = [
+  devCommand,
+  connectCommand,
+  generateCommand,
+  reactorCommand,
+  helpCommand,
+  installCommand,
+  uninstallCommand,
+  serviceCommand
+];
+function registerCommands(program) {
+  commands.forEach((command) => command(program));
+}
+
+export {
+  commands,
+  registerCommands
+};