cligr 1.0.1 → 1.0.2

package/dist/commands/config.js

@@ -0,0 +1,102 @@
+import { spawn, spawnSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+const CONFIG_FILENAME = ".cligr.yml";
+const TEMPLATE = `# Cligr Configuration
+
+groups:
+  web:
+    tool: docker
+    restart: false
+    items:
+      - "nginx,8080"      # $1=nginx (name), $2=8080 (port)
+      - "nginx,3000"
+
+  simple:
+    tool: node
+    items:
+      - "server"          # $1=server (name only)
+
+tools:
+  docker:
+    cmd: "docker run -p $2:$2 nginx"   # $1=name, $2=port
+  node:
+    cmd: "node $1.js"                   # $1=file name
+
+# Syntax:
+# - Items are comma-separated: "name,arg2,arg3"
+# - $1 = name (first value)
+# - $2, $3... = additional arguments
+# - If no tool specified, executes directly
+`;
+function detectEditor() {
+  const platform = process.platform;
+  const whichCmd = platform === "win32" ? "where" : "which";
+  const codeCheck = spawnSync(whichCmd, ["code"], { stdio: "ignore" });
+  if (codeCheck.status === 0) {
+    return "code";
+  }
+  if (process.env.EDITOR) {
+    return process.env.EDITOR;
+  }
+  if (platform === "win32") {
+    return "notepad.exe";
+  }
+  return "vim";
+}
+function spawnEditor(filePath, editorCmd) {
+  const platform = process.platform;
+  const whichCmd = platform === "win32" ? "where" : "which";
+  const editorCheck = spawnSync(whichCmd, [editorCmd], { stdio: "ignore" });
+  if (editorCheck.status !== 0 && editorCmd !== process.env.EDITOR) {
+    throw new Error(
+      `Editor '${editorCmd}' not found.
+Install VS Code or set EDITOR environment variable.
+
+Example:
+  export EDITOR=vim
+  cligr config`
+    );
+  }
+  const child = spawn(editorCmd, [filePath], {
+    detached: true,
+    stdio: "ignore",
+    shell: platform === "win32"
+  });
+  child.unref();
+}
+function createTemplate(filePath) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, TEMPLATE, "utf-8");
+}
+async function configCommand() {
+  try {
+    const homeDirConfig = path.join(os.homedir(), CONFIG_FILENAME);
+    const currentDirConfig = path.resolve(CONFIG_FILENAME);
+    let configPath;
+    if (fs.existsSync(homeDirConfig)) {
+      configPath = homeDirConfig;
+    } else if (fs.existsSync(currentDirConfig)) {
+      configPath = currentDirConfig;
+    } else {
+      configPath = homeDirConfig;
+    }
+    if (!fs.existsSync(configPath)) {
+      createTemplate(configPath);
+    }
+    const editor = detectEditor();
+    spawnEditor(configPath, editor);
+    console.log(`Opening ${configPath} in ${editor}...`);
+    return 0;
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    return 1;
+  }
+}
+export {
+  configCommand
+};

package/dist/commands/down.js

@@ -0,0 +1,26 @@
+import { ProcessManager } from "../process/manager.js";
+async function downCommand(groupName) {
+  const manager = new ProcessManager();
+  const result = await manager.killGroupByPid(groupName);
+  if (result.killed === 0 && result.notRunning === 0) {
+    console.log(`Group '${groupName}' is not running`);
+    return 0;
+  }
+  if (result.killed > 0) {
+    console.log(`Stopped ${result.killed} process(es) for group '${groupName}'`);
+  }
+  if (result.notRunning > 0) {
+    console.log(`Cleaned up ${result.notRunning} stale PID file(s) for group '${groupName}'`);
+  }
+  if (result.errors.length > 0) {
+    console.error("Errors while stopping processes:");
+    for (const err of result.errors) {
+      console.error(`  ${err}`);
+    }
+    return 1;
+  }
+  return 0;
+}
+export {
+  downCommand
+};

package/dist/commands/groups.js

@@ -0,0 +1,43 @@
+import { ConfigLoader } from "../config/loader.js";
+async function groupsCommand(verbose) {
+  const loader = new ConfigLoader();
+  try {
+    const groupNames = loader.listGroups();
+    if (groupNames.length === 0) {
+      return 0;
+    }
+    if (verbose) {
+      const config = loader.load();
+      const details = [];
+      for (const name of groupNames) {
+        const group = config.groups[name];
+        details.push({
+          name,
+          tool: group.tool || "(none)",
+          restart: group.restart || "(none)",
+          itemCount: group.items.length
+        });
+      }
+      const maxNameLen = Math.max("GROUP".length, ...details.map((d) => d.name.length));
+      const maxToolLen = Math.max("TOOL".length, ...details.map((d) => d.tool.length));
+      const maxRestartLen = Math.max("RESTART".length, ...details.map((d) => d.restart.length));
+      const header = "GROUP".padEnd(maxNameLen) + "  " + "TOOL".padEnd(maxToolLen) + "  " + "RESTART".padEnd(maxRestartLen) + "  ITEMS";
+      console.log(header);
+      for (const d of details) {
+        const row = d.name.padEnd(maxNameLen) + "  " + d.tool.padEnd(maxToolLen) + "  " + d.restart.padEnd(maxRestartLen) + "  " + String(d.itemCount);
+        console.log(row);
+      }
+    } else {
+      for (const name of groupNames) {
+        console.log(name);
+      }
+    }
+    return 0;
+  } catch (err) {
+    console.error(err.message);
+    return 1;
+  }
+}
+export {
+  groupsCommand
+};

package/dist/commands/ls.js

@@ -0,0 +1,23 @@
+import { ConfigLoader } from "../config/loader.js";
+async function lsCommand(groupName) {
+  const loader = new ConfigLoader();
+  try {
+    const { config } = loader.getGroup(groupName);
+    console.log(`
+Group: ${groupName}`);
+    console.log(`Tool: ${config.tool}`);
+    console.log(`Restart: ${config.restart}`);
+    console.log("\nItems:");
+    for (const item of config.items) {
+      console.log(`  - ${item}`);
+    }
+    console.log("");
+    return 0;
+  } catch (err) {
+    console.error(err.message);
+    return 1;
+  }
+}
+export {
+  lsCommand
+};

package/dist/commands/up.js

@@ -0,0 +1,39 @@
+import { ConfigLoader } from "../config/loader.js";
+import { TemplateExpander } from "../process/template.js";
+import { ProcessManager } from "../process/manager.js";
+import { PidStore } from "../process/pid-store.js";
+async function upCommand(groupName) {
+  const loader = new ConfigLoader();
+  const manager = new ProcessManager();
+  const pidStore = new PidStore();
+  try {
+    await pidStore.cleanupStalePids();
+    const { config, tool, toolTemplate } = loader.getGroup(groupName);
+    const items = config.items.map(
+      (itemStr, index) => TemplateExpander.parseItem(tool, toolTemplate, itemStr, index)
+    );
+    manager.spawnGroup(groupName, items, config.restart);
+    console.log(`Started group ${groupName} with ${items.length} process(es)`);
+    console.log("Press Ctrl+C to stop...");
+    return new Promise((resolve) => {
+      const cleanup = async () => {
+        console.log("\nShutting down...");
+        process.removeListener("SIGINT", cleanup);
+        process.removeListener("SIGTERM", cleanup);
+        await manager.killAll();
+        resolve(0);
+      };
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "ConfigError") {
+      console.error(error.message);
+      return 1;
+    }
+    throw error;
+  }
+}
+export {
+  upCommand
+};

package/dist/config/loader.js

@@ -0,0 +1,82 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import yaml from "js-yaml";
+const CONFIG_FILENAME = ".cligr.yml";
+class ConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+}
+class ConfigLoader {
+  configPath;
+  constructor(configPath) {
+    if (configPath) {
+      this.configPath = path.resolve(configPath);
+    } else {
+      const homeDirConfig = path.join(os.homedir(), CONFIG_FILENAME);
+      const currentDirConfig = path.resolve(CONFIG_FILENAME);
+      if (fs.existsSync(homeDirConfig)) {
+        this.configPath = homeDirConfig;
+      } else if (fs.existsSync(currentDirConfig)) {
+        this.configPath = currentDirConfig;
+      } else {
+        this.configPath = homeDirConfig;
+      }
+    }
+  }
+  load() {
+    if (!fs.existsSync(this.configPath)) {
+      throw new ConfigError(
+        `Config file not found. Looking for:
+  - ${path.join(os.homedir(), CONFIG_FILENAME)}
+  - ${path.resolve(CONFIG_FILENAME)}`
+      );
+    }
+    const content = fs.readFileSync(this.configPath, "utf-8");
+    let config;
+    try {
+      config = yaml.load(content);
+    } catch (err) {
+      throw new ConfigError(`Invalid YAML: ${err.message}`);
+    }
+    return this.validate(config);
+  }
+  validate(config) {
+    if (!config || typeof config !== "object") {
+      throw new ConfigError("Config must be an object");
+    }
+    const cfg = config;
+    if (!cfg.groups || typeof cfg.groups !== "object") {
+      throw new ConfigError('Config must have a "groups" object');
+    }
+    return cfg;
+  }
+  getGroup(name) {
+    const config = this.load();
+    const group = config.groups[name];
+    if (!group) {
+      const available = Object.keys(config.groups).join(", ");
+      throw new ConfigError(`Unknown group: ${name}. Available: ${available}`);
+    }
+    let toolTemplate = null;
+    let tool = null;
+    if (config.tools && config.tools[group.tool]) {
+      toolTemplate = config.tools[group.tool].cmd;
+      tool = group.tool;
+    } else {
+      tool = null;
+      toolTemplate = null;
+    }
+    return { config: group, tool, toolTemplate };
+  }
+  listGroups() {
+    const config = this.load();
+    return Object.keys(config.groups);
+  }
+}
+export {
+  ConfigError,
+  ConfigLoader
+};