@powerhousedao/ph-cli 0.29.1 → 0.31.0

package/dist/chunk-X2RNXISI.js

@@ -0,0 +1,98 @@
+import {
+  SUPPORTED_PACKAGE_MANAGERS,
+  getPackageManagerFromLockfile,
+  getProjectInfo,
+  packageManagers,
+  updateConfigFile
+} from "./chunk-FDMMJENR.js";
+
+// src/commands/uninstall.ts
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+function uninstallDependency(packageManager, dependencies, projectPath, workspace) {
+  if (!fs.existsSync(projectPath)) {
+    throw new Error(`Project path not found: ${projectPath}`);
+  }
+  const manager = packageManagers[packageManager];
+  let uninstallCommand2 = manager.uninstallCommand.replace(
+    "{{dependency}}",
+    dependencies.join(" ")
+  );
+  if (workspace) {
+    uninstallCommand2 += ` ${manager.workspaceOption}`;
+  }
+  const commandOptions = { cwd: projectPath };
+  execSync(uninstallCommand2, {
+    stdio: "inherit",
+    ...commandOptions
+  });
+}
+var uninstall = (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>>> uninstallDependency 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("Uninstalling dependencies \u{1F4E6} ...");
+    uninstallDependency(
+      packageManager,
+      dependencies,
+      projectInfo.path,
+      options.workspace
+    );
+    console.log("Dependency uninstalled successfully \u{1F389}");
+  } catch (error) {
+    console.error("\u274C Failed to uninstall dependencies");
+    throw error;
+  }
+  if (options.debug) {
+    console.log("\n>>> updateConfigFile arguments:");
+    console.log(">>> dependencies", dependencies);
+    console.log(">>> projectPath", projectInfo.path);
+    console.log(">>> task", "uninstall");
+  }
+  try {
+    console.log("\u2699\uFE0F Updating powerhouse config file...");
+    updateConfigFile(dependencies, projectInfo.path, "uninstall");
+    console.log("Config file updated successfully \u{1F389}");
+  } catch (error) {
+    console.error("\u274C Failed to update config file");
+    throw error;
+  }
+};
+function uninstallCommand(program) {
+  program.command("uninstall").alias("remove").description("Uninstall a powerhouse dependency").argument("[dependencies...]", "Names of the dependencies to remove").option("-g, --global", "Remove the dependency globally").option("--debug", "Show additional logs").option(
+    "-w, --workspace",
+    "Remove the dependency in the workspace (use this option for monorepos)"
+  ).option(
+    "--package-manager <packageManager>",
+    "force package manager to use"
+  ).action(uninstall);
+}
+
+export {
+  uninstallDependency,
+  uninstall,
+  uninstallCommand
+};

package/dist/chunk-ZN4M6TJ2.js

@@ -0,0 +1,119 @@
+// src/commands/service.ts
+import { getConfig } from "@powerhousedao/config/powerhouse";
+import { Argument } from "commander";
+import pm2 from "pm2";
+var actions = ["start", "stop", "status", "list", "install", "save"];
+var services = ["switchboard", "connect", "all"];
+var switchboardPort = 8442;
+var connectPort = 8443;
+var manageService = async (action, service) => {
+  try {
+    const config = getConfig();
+    if (config.switchboard?.port) {
+      switchboardPort = config.switchboard.port;
+    }
+    if (config.studio?.port) {
+      connectPort = config.studio.port;
+    }
+    pm2.connect((err) => {
+      switch (action) {
+        case "start":
+          startServices(service);
+          break;
+        case "stop":
+          stopServices(service);
+          break;
+        case "status":
+          statusServices();
+          break;
+      }
+    });
+  } catch (error) {
+    console.error(error);
+  }
+};
+function serviceCommand(program) {
+  program.command("service").description("Manage services").addArgument(new Argument("action").choices(actions).default("list")).addArgument(
+    new Argument("service").choices(services).argOptional().default("all")
+  ).action(manageService);
+}
+function startServices(service) {
+  if (service === "switchboard" || service === "all") {
+    const switchboardOptions = {
+      name: "switchboard",
+      script: "npx ph-cli switchboard"
+    };
+    console.log("Starting Switchboard...");
+    pm2.start(switchboardOptions, (err) => {
+      if (err) {
+        console.log(err.name);
+      }
+      dumpServices();
+    });
+    console.log("Switchboard started");
+  }
+  if (service === "connect" || service === "all") {
+    const connectOptions = {
+      name: "connect",
+      script: "npx ph-cli connect",
+      args: ["--port", connectPort.toString()]
+    };
+    console.log("Starting connect...");
+    pm2.start(connectOptions, (err) => {
+      if (err) {
+        throw new Error(err.message);
+      }
+      dumpServices();
+    });
+    console.log("Connect started");
+  }
+}
+function dumpServices() {
+  pm2.dump((err) => {
+    if (err) {
+      throw new Error(err.message);
+    }
+    statusServices();
+  });
+}
+function stopServices(service) {
+  if (service === "all" || service === "connect") {
+    pm2.stop("connect", (err) => {
+      if (err) {
+        throw new Error(err.message);
+      }
+      dumpServices();
+    });
+  }
+  if (service === "all" || service === "switchboard") {
+    pm2.stop("switchboard", (err) => {
+      if (err) {
+        throw new Error(err.message);
+      }
+      dumpServices();
+    });
+  }
+}
+function statusServices() {
+  pm2.list((err, list) => {
+    const formattedList = list.map((item) => {
+      return {
+        id: item.pm_id,
+        name: item.name,
+        pid: item.pid,
+        uptime: item.pm2_env?.pm_uptime,
+        restarts: item.pm2_env?.unstable_restarts,
+        status: item.pm2_env?.status,
+        mem: item.monit?.memory,
+        cpu: item.monit?.cpu
+      };
+    });
+    console.table(formattedList);
+    process.exit(0);
+  });
+}
+
+export {
+  manageService,
+  serviceCommand
+};

package/dist/cli.js

@@ -1,10 +1,20 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import registerCommands from './commands/index.js';
+import {
+  registerCommands
+} from "./chunk-PUQARXW2.js";
+import "./chunk-E3EWRF5U.js";
+import "./chunk-ZN4M6TJ2.js";
+import "./chunk-X2RNXISI.js";
+import "./chunk-FDMMJENR.js";
+import "./chunk-27FF7J6K.js";
+import "./chunk-CWUXPR5K.js";
+import "./chunk-6O6TUXJK.js";
+import "./chunk-OH5NZOCQ.js";
+import "./chunk-KPMNRIJU.js";
 
-const program = new Command();
+// src/cli.ts
+import { Command } from "commander";
+var program = new Command();
 program.name("ph-cli").description("CLI tool for Powerhouse DAO").version("1.0.0");
 registerCommands(program);
 program.parse(process.argv);
-//# sourceMappingURL=cli.js.map
-//# sourceMappingURL=cli.js.map

package/dist/commands/connect.js

@@ -1,42 +1,8 @@
-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 { connectCommand, startConnect };
-//# sourceMappingURL=connect.js.map
-//# sourceMappingURL=connect.js.map
+import {
+  connectCommand,
+  startConnect
+} from "../chunk-27FF7J6K.js";
+export {
+  connectCommand,
+  startConnect
+};

package/dist/commands/dev.js

@@ -1,98 +1,9 @@
-import path, { dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { fork } from 'node:child_process';
-import { blue, red, green } from 'colorette';
-import { DefaultReactorOptions } from './reactor.js';
-
-const __dirname = import.meta.dirname || dirname(fileURLToPath(import.meta.url));
-function spawnLocalReactor(options) {
-  const child = fork(
-    path.join(__dirname, "reactor.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(`[Reactor]: ${line}
-`));
-      }
-    });
-    child.stderr.on("error", (data) => {
-      process.stderr.write(red(`[Reactor]: ${data.toString()}`));
-    });
-    child.on("error", (err) => {
-      process.stderr.write(red(`[Reactor]: ${err}`));
-    });
-    child.on("exit", (code) => {
-      console.log(`Reactor 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}`);
-    });
-  });
-}
-const dev = async ({
-  generate,
-  watch,
-  reactorPort = DefaultReactorOptions.port,
-  configFile
-}) => {
-  try {
-    const { driveUrl } = await spawnLocalReactor({
-      generate,
-      port: reactorPort,
-      watch
-    });
-    await spawnConnect({ configFile }, driveUrl);
-  } catch (error) {
-    console.error(error);
-  }
+import {
+  dev,
+  devCommand
+} from "../chunk-CWUXPR5K.js";
+import "../chunk-6O6TUXJK.js";
+export {
+  dev,
+  devCommand
 };
-function devCommand(program) {
-  program.command("dev").description("Starts dev environment").option("--generate", "generate code when document model is updated").option("--reactor-port <port>", "port to use for the reactor").option(
-    "--config-file <configFile>",
-    "Path to the powerhouse.config.js file"
-  ).option(
-    "-w, --watch",
-    "if the reactor should watch for local changes to document models and processors"
-  ).action(dev);
-}
-
-export { dev, devCommand };
-//# sourceMappingURL=dev.js.map
-//# sourceMappingURL=dev.js.map

package/dist/commands/generate.js

@@ -1,70 +1,8 @@
-import { promptDirectories, generateEditor, generateProcessor, generateSubgraph, generateFromFile, generate as generate$1 } from '@powerhousedao/codegen';
-import { getConfig } from '@powerhousedao/config/powerhouse';
-
-const 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
-  };
-  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 (filePath) {
-    await generateFromFile(filePath, config);
-    return;
-  }
-  await generate$1(config);
+import {
+  generate,
+  generateCommand
+} from "../chunk-OH5NZOCQ.js";
+export {
+  generate,
+  generateCommand
 };
-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("-sf, --skip-format", "Skip formatting the generated code").option("-w, --watch", "Watch the generated code").action(generate);
-}
-
-export { generate, generateCommand };
-//# sourceMappingURL=generate.js.map
-//# sourceMappingURL=generate.js.map

package/dist/commands/help.js

@@ -1,9 +1,6 @@
-function helpCommand(program) {
-  program.command("help").description("Display help information").action(() => {
-    program.help();
-  });
-}
-
-export { helpCommand };
-//# sourceMappingURL=help.js.map
-//# sourceMappingURL=help.js.map
+import {
+  helpCommand
+} from "../chunk-KPMNRIJU.js";
+export {
+  helpCommand
+};

package/dist/commands/index.js

@@ -1,32 +1,61 @@
-import { connectCommand } from './connect.js';
-import { devCommand } from './dev.js';
-export * from './dev.js';
-import { generateCommand } from './generate.js';
-export * from './generate.js';
-import { helpCommand } from './help.js';
-export * from './help.js';
-import { initCommand } from './init.js';
-export * from './init.js';
-import { installCommand } from './install.js';
-import { reactorCommand } from './reactor.js';
-export * from './reactor.js';
-import { serviceCommand } from './service.js';
-export * from './service.js';
-
-const commands = [
-  initCommand,
-  devCommand,
+import {
+  commands,
+  registerCommands
+} from "../chunk-PUQARXW2.js";
+import {
+  install,
+  installCommand,
+  installDependency
+} from "../chunk-E3EWRF5U.js";
+import {
+  manageService,
+  serviceCommand
+} from "../chunk-ZN4M6TJ2.js";
+import {
+  uninstall,
+  uninstallCommand,
+  uninstallDependency
+} from "../chunk-X2RNXISI.js";
+import "../chunk-FDMMJENR.js";
+import {
   connectCommand,
-  generateCommand,
+  startConnect
+} from "../chunk-27FF7J6K.js";
+import {
+  dev,
+  devCommand
+} from "../chunk-CWUXPR5K.js";
+import {
+  DefaultSwitchboardOptions,
   reactorCommand,
+  switchboard
+} from "../chunk-6O6TUXJK.js";
+import {
+  generate,
+  generateCommand
+} from "../chunk-OH5NZOCQ.js";
+import {
+  helpCommand
+} from "../chunk-KPMNRIJU.js";
+export {
+  DefaultSwitchboardOptions,
+  commands,
+  connectCommand,
+  registerCommands as default,
+  dev,
+  devCommand,
+  generate,
+  generateCommand,
   helpCommand,
+  install,
   installCommand,
-  serviceCommand
-];
-function registerCommands(program) {
-  commands.forEach((command) => command(program));
-}
-
-export { commands, registerCommands as default };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+  installDependency,
+  manageService,
+  reactorCommand,
+  serviceCommand,
+  startConnect,
+  switchboard,
+  uninstall,
+  uninstallCommand,
+  uninstallDependency
+};