@moxxy/cli 0.0.1

package/dist/chunk-CTBVTTBG.mjs

@@ -0,0 +1,440 @@
+// src/cli.ts
+import { Command } from "commander";
+
+// src/config/config-manager.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { moxxyConfigSchema } from "@moxxy/types";
+
+// src/config/config-defaults.ts
+var DEFAULT_CONFIG = {
+  version: 1,
+  webhook: { port: 3456, host: "0.0.0.0", path: "/webhook/github" },
+  repos: []
+};
+var CONFIG_DIR = ".moxxy";
+var CONFIG_FILE = "config.json";
+
+// src/config/config-manager.ts
+var ConfigManager = class {
+  configPath;
+  config = null;
+  constructor(configDir) {
+    const base = configDir || join(homedir(), CONFIG_DIR);
+    this.configPath = join(base, CONFIG_FILE);
+  }
+  async load() {
+    if (!existsSync(this.configPath)) {
+      throw new Error(`Config not found at ${this.configPath}. Run 'moxxy config init' first.`);
+    }
+    const raw = await readFile(this.configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    this.config = moxxyConfigSchema.parse(parsed);
+    return this.config;
+  }
+  async save(config) {
+    const dir = join(this.configPath, "..");
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    this.config = moxxyConfigSchema.parse(config);
+    await writeFile(this.configPath, JSON.stringify(this.config, null, 2) + "\n");
+  }
+  async init(config) {
+    const merged = { ...DEFAULT_CONFIG, ...config };
+    await this.save(merged);
+    return merged;
+  }
+  getConfig() {
+    if (!this.config) throw new Error("Config not loaded. Call load() first.");
+    return this.config;
+  }
+  async addRepo(repo) {
+    const config = this.getConfig();
+    const exists = config.repos.find((r) => r.owner === repo.owner && r.repo === repo.repo);
+    if (exists) throw new Error(`Repo ${repo.owner}/${repo.repo} already configured.`);
+    config.repos.push(repo);
+    await this.save(config);
+  }
+  async removeRepo(owner, repo) {
+    const config = this.getConfig();
+    config.repos = config.repos.filter((r) => !(r.owner === owner && r.repo === repo));
+    await this.save(config);
+  }
+  async set(key, value) {
+    const config = this.getConfig();
+    const keys = key.split(".");
+    let obj = config;
+    for (let i = 0; i < keys.length - 1; i++) {
+      obj = obj[keys[i]] ??= {};
+    }
+    obj[keys[keys.length - 1]] = value;
+    await this.save(config);
+  }
+  get(key) {
+    const config = this.getConfig();
+    const keys = key.split(".");
+    let obj = config;
+    for (const k of keys) {
+      obj = obj?.[k];
+    }
+    return obj;
+  }
+  get path() {
+    return this.configPath;
+  }
+};
+
+// src/utils/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+function info(message) {
+  console.log(`${chalk.cyan("i")} ${message}`);
+}
+function success(message) {
+  console.log(`${chalk.green("\u2714")} ${message}`);
+}
+function error(message) {
+  console.error(`${chalk.red("\u2716")} ${message}`);
+}
+function spinner(text) {
+  return ora({ text, color: "cyan" }).start();
+}
+function printBanner() {
+  console.log();
+  console.log(chalk.bold.cyan("  Moxxy"));
+  console.log(chalk.dim("  Agent orchestration platform"));
+  console.log();
+}
+function section(title) {
+  console.log();
+  console.log(chalk.bold(title));
+  console.log(chalk.dim("\u2500".repeat(title.length)));
+}
+function keyValue(key, value) {
+  console.log(`  ${chalk.dim(key + ":")} ${value}`);
+}
+function listItem(text) {
+  console.log(`  ${chalk.dim("\u2022")} ${text}`);
+}
+
+// src/commands/start.ts
+var SDK_NAMES = {
+  molt: "Molt Gateway",
+  claude: "Claude CLI"
+};
+async function createSDK(config) {
+  const provider = config.sdk || "molt";
+  const sdkName = SDK_NAMES[provider] || provider;
+  if (provider === "claude") {
+    const { ClaudeSDK } = await import("@moxxy/claude");
+    const claudeConfig = config.claude || {};
+    const sdk2 = await ClaudeSDK.create({
+      cliPath: claudeConfig.cliPath,
+      model: claudeConfig.model,
+      timeout: claudeConfig.timeout,
+      permissionMode: claudeConfig.permissionMode
+    });
+    return { sdk: sdk2, sdkName };
+  }
+  const { MoltSDK } = await import("@moxxy/molt");
+  const sdk = await MoltSDK.create({
+    gatewayUrl: config.gateway.url,
+    authToken: config.gateway.authToken,
+    deviceId: config.gateway.deviceId,
+    devicePrivateKey: config.gateway.devicePrivateKey
+  });
+  return { sdk, sdkName };
+}
+function registerStartCommand(program) {
+  program.command("start").description("Start Moxxy orchestration").action(async () => {
+    const configManager = new ConfigManager();
+    try {
+      const config = await configManager.load();
+      printBanner();
+      const { MoltAgentSupervisor } = await import("@moxxy/agents");
+      const { IntegrationManager } = await import("@moxxy/integration-base");
+      const { GitHubIntegration } = await import("@moxxy/integration-github");
+      const provider = config.sdk || "molt";
+      const sdkName = SDK_NAMES[provider] || provider;
+      const connectSpinner = spinner(`Connecting to ${sdkName}`);
+      try {
+        const { sdk } = await createSDK(config);
+        connectSpinner.succeed(`Connected to ${sdkName}`);
+        const supervisorSpinner = spinner("Initializing agent supervisor");
+        const supervisor = new MoltAgentSupervisor(sdk);
+        const agentId = config.agent?.moltAgentId;
+        if (agentId) {
+          await supervisor.assignAgent(agentId, "developer");
+          supervisorSpinner.succeed(`Agent ${chalk.bold(agentId)} assigned`);
+        } else {
+          supervisorSpinner.succeed("Supervisor ready (no agent configured)");
+        }
+        const integrationManager = new IntegrationManager();
+        const github = new GitHubIntegration();
+        integrationManager.register(github);
+        integrationManager.on("*", (event) => {
+          info(
+            `${chalk.dim(`[${event.integration}]`)} ${event.type}: ${JSON.stringify(event.data).slice(0, 200)}`
+          );
+        });
+        const webhookConfig = config.webhook || {
+          port: 3456,
+          host: "0.0.0.0",
+          path: "/webhook/github"
+        };
+        const webhookSpinner = spinner("Starting webhook server");
+        await github.connect({
+          github: config.github,
+          webhook: webhookConfig,
+          sdk,
+          supervisor,
+          moltAgentId: agentId || ""
+        });
+        webhookSpinner.succeed(
+          `Webhook server listening on ${chalk.cyan(`${webhookConfig.host}:${webhookConfig.port}${webhookConfig.path}`)}`
+        );
+        if (config.repos.length > 0) {
+          const watchSpinner = spinner(
+            `Watching ${config.repos.length} repositories`
+          );
+          const targets = config.repos.map((r) => `${r.owner}/${r.repo}`);
+          await github.watch(targets);
+          watchSpinner.succeed(
+            `Watching ${chalk.bold(String(targets.length))} repositories: ${targets.join(", ")}`
+          );
+        }
+        console.log();
+        success(chalk.bold("Moxxy is running.") + " Press Ctrl+C to stop.");
+        const shutdown = async () => {
+          console.log();
+          info("Shutting down...");
+          await integrationManager.stopAll();
+          sdk.disconnect();
+          success("Shutdown complete.");
+          process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        await new Promise(() => {
+        });
+      } catch (innerErr) {
+        connectSpinner.fail(
+          `Failed to start: ${innerErr instanceof Error ? innerErr.message : innerErr}`
+        );
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      error(`Failed to start: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/repo.ts
+function registerRepoCommand(program) {
+  const repo = program.command("repo").description("Manage watched repositories");
+  repo.command("add").description("Add a repository to watch").argument("<repo>", "Repository in owner/repo format").option("--branch <branch>", "Default branch", "main").option("--events <events>", "Comma-separated events to watch", "issues.opened,issues.labeled").action(async (repoStr, options) => {
+    const [owner, name] = repoStr.split("/");
+    if (!owner || !name) {
+      error("Repository must be in owner/repo format");
+      process.exitCode = 1;
+      return;
+    }
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      await manager.addRepo({
+        owner,
+        repo: name,
+        defaultBranch: options.branch,
+        enabledEvents: options.events.split(",")
+      });
+      success(`Added ${chalk.bold(`${owner}/${name}`)}`);
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  repo.command("list").description("List watched repositories").action(async () => {
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      const config = manager.getConfig();
+      if (config.repos.length === 0) {
+        info("No repositories configured.");
+        return;
+      }
+      section(`Repositories (${config.repos.length})`);
+      for (const r of config.repos) {
+        listItem(
+          `${chalk.bold(`${r.owner}/${r.repo}`)} ${chalk.dim(`branch: ${r.defaultBranch}`)} ${chalk.dim(`events: ${r.enabledEvents.join(", ")}`)}`
+        );
+      }
+      console.log();
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  repo.command("remove").description("Remove a watched repository").argument("<repo>", "Repository in owner/repo format").action(async (repoStr) => {
+    const [owner, name] = repoStr.split("/");
+    if (!owner || !name) {
+      error("Repository must be in owner/repo format");
+      process.exitCode = 1;
+      return;
+    }
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      await manager.removeRepo(owner, name);
+      success(`Removed ${chalk.bold(`${owner}/${name}`)}`);
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/config.ts
+function registerConfigCommand(program) {
+  const config = program.command("config").description("Manage Moxxy configuration");
+  config.command("init").description("Initialize Moxxy configuration").requiredOption("--gateway-url <url>", "Gateway URL (for molt SDK)").requiredOption("--github-token <token>", "GitHub personal access token").option("--sdk <provider>", "SDK provider (molt or claude)", "molt").option("--webhook-secret <secret>", "GitHub webhook secret").option("--webhook-port <port>", "Webhook server port", "3456").option("--agent-id <id>", "Agent ID").option("--claude-model <model>", "Claude model (for claude SDK)", "claude-sonnet-4-5").option("--claude-cli-path <path>", "Claude CLI path (for claude SDK)", "claude").action(async (options) => {
+    const manager = new ConfigManager();
+    try {
+      await manager.init({
+        version: 1,
+        sdk: options.sdk,
+        gateway: { url: options.gatewayUrl },
+        github: { token: options.githubToken, webhookSecret: options.webhookSecret },
+        webhook: {
+          port: parseInt(options.webhookPort, 10),
+          host: "0.0.0.0",
+          path: "/webhook/github"
+        },
+        repos: [],
+        agent: options.agentId ? { moltAgentId: options.agentId } : void 0,
+        claude: options.sdk === "claude" ? { cliPath: options.claudeCliPath, model: options.claudeModel } : void 0
+      });
+      success(`Config created at ${chalk.dim(manager.path)}`);
+    } catch (err) {
+      error(`Failed to init config: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  config.command("set").description("Set a config value").argument("<key>", "Config key (dot notation)").argument("<value>", "Config value").action(async (key, value) => {
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      let parsed = value;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+      }
+      await manager.set(key, parsed);
+      success(`Set ${chalk.bold(key)}`);
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  config.command("get").description("Get a config value").argument("<key>", "Config key (dot notation)").action(async (key) => {
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      const value = manager.get(key);
+      console.log(chalk.cyan(JSON.stringify(value, null, 2)));
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/status.ts
+function registerStatusCommand(program) {
+  program.command("status").description("Show Moxxy configuration status").action(async () => {
+    const configManager = new ConfigManager();
+    try {
+      const config = await configManager.load();
+      printBanner();
+      const provider = config.sdk || "molt";
+      section("SDK");
+      keyValue("Provider", chalk.bold(provider));
+      if (provider === "molt") {
+        section("Gateway");
+        keyValue("URL", chalk.cyan(config.gateway.url));
+        keyValue(
+          "Auth",
+          config.gateway.authToken ? chalk.green("configured") : chalk.dim("not set")
+        );
+        keyValue(
+          "Device",
+          config.gateway.deviceId || chalk.dim("not set")
+        );
+      }
+      if (provider === "claude" && config.claude) {
+        section("Claude");
+        keyValue("CLI Path", chalk.cyan(config.claude.cliPath || "claude"));
+        keyValue("Model", chalk.cyan(config.claude.model || "claude-sonnet-4-5"));
+      }
+      section("GitHub");
+      keyValue(
+        "Token",
+        config.github.token ? chalk.yellow("***" + config.github.token.slice(-4)) : chalk.dim("not set")
+      );
+      keyValue(
+        "Webhook Secret",
+        config.github.webhookSecret ? chalk.green("configured") : chalk.dim("not set")
+      );
+      if (config.webhook) {
+        section("Webhook Server");
+        keyValue("Port", chalk.cyan(String(config.webhook.port)));
+        keyValue("Path", chalk.cyan(config.webhook.path));
+      }
+      section(`Repositories (${config.repos.length})`);
+      if (config.repos.length === 0) {
+        keyValue("", chalk.dim("None configured"));
+      } else {
+        for (const r of config.repos) {
+          listItem(
+            `${chalk.bold(`${r.owner}/${r.repo}`)} ${chalk.dim(`(${r.defaultBranch})`)}`
+          );
+        }
+      }
+      if (config.agent) {
+        section("Agent");
+        keyValue(
+          "Agent ID",
+          config.agent.moltAgentId || chalk.dim("not set")
+        );
+        keyValue(
+          "Max Concurrent",
+          String(config.agent.maxConcurrentTasks || 1)
+        );
+      }
+      console.log();
+    } catch (err) {
+      error(`${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/cli.ts
+function createProgram() {
+  const program = new Command();
+  program.name("moxxy").description("Moxxy - Agent orchestration platform").version("1.0.0");
+  registerStartCommand(program);
+  registerRepoCommand(program);
+  registerConfigCommand(program);
+  registerStatusCommand(program);
+  return program;
+}
+
+export {
+  ConfigManager,
+  createProgram
+};