@moxxy/cli 0.0.4 → 0.0.6

package/dist/chunk-CAUXONEF.mjs

@@ -0,0 +1,1131 @@
+import {
+  PIPELINE_STAGES,
+  moxxyConfigSchema
+} from "./chunk-GSNMMI3H.mjs";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/agent.ts
+import prompts from "prompts";
+
+// src/config/config-manager.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// 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 warn(message) {
+  console.warn(`${chalk.yellow("\u26A0")} ${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/agent.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("./src-D5HMDDVE.mjs");
+    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 };
+  }
+  if (!config.gateway) {
+    throw new Error(
+      'Gateway configuration is required for the molt SDK. Run "moxxy config init --sdk molt --gateway-url <url>".'
+    );
+  }
+  const { MoltSDK } = await import("./dist-UYA4RJUH.mjs");
+  const sdk = await MoltSDK.create({
+    gatewayUrl: config.gateway.url,
+    authToken: config.gateway.authToken,
+    deviceId: config.gateway.deviceId,
+    devicePrivateKey: config.gateway.devicePrivateKey
+  });
+  return { sdk, sdkName };
+}
+async function loadConfig() {
+  const manager = new ConfigManager();
+  return manager.load();
+}
+function registerAgentCommand(program) {
+  const agent = program.command("agent").description("Manage Moxxy agents");
+  agent.command("list").description("List all agents").action(async () => {
+    try {
+      const config = await loadConfig();
+      const connectSpinner = spinner("Connecting to SDK");
+      const { sdk, sdkName } = await createSDK(config);
+      connectSpinner.succeed(`Connected to ${sdkName}`);
+      const listSpinner = spinner("Fetching agents");
+      const result = await sdk.agents.list();
+      listSpinner.stop();
+      const agents = result.agents ?? [];
+      if (agents.length === 0) {
+        console.log();
+        warn("No agents found.");
+        info(`Run ${chalk.cyan("moxxy agent create <id>")} to create one.`);
+        sdk.disconnect();
+        return;
+      }
+      const configuredId = config.agent?.moltAgentId;
+      section(`Agents (${agents.length})`);
+      for (const a of agents) {
+        const id = a.agentId || a.id;
+        const tags = [];
+        if (a.isDefault) tags.push(chalk.cyan("default"));
+        if (id === configuredId) tags.push(chalk.green("configured"));
+        if (a.heartbeat?.enabled) tags.push(chalk.dim("heartbeat"));
+        const sessionCount = a.sessions?.count ?? 0;
+        const sessionsInfo = chalk.dim(
+          `${sessionCount} session${sessionCount !== 1 ? "s" : ""}`
+        );
+        const tagStr = tags.length > 0 ? ` ${tags.join(" ")}` : "";
+        listItem(`${chalk.bold(id)}${tagStr}  ${sessionsInfo}`);
+      }
+      if (result.defaultAgentId) {
+        console.log();
+        keyValue("Default", chalk.cyan(result.defaultAgentId));
+      }
+      console.log();
+      sdk.disconnect();
+    } catch (err) {
+      error(`${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  agent.command("create").description("Create a new agent (interactive when no flags provided)").argument("[id]", "Agent ID (unique name)").option("-w, --workspace <path>", "Workspace directory").option("-m, --model <model>", "Primary model (e.g. anthropic/claude-sonnet-4-5)").option("--default", "Set as the default agent").option("--name <name>", "Display name").option("--theme <theme>", "Persona / theme description").action(async (id, options) => {
+    try {
+      const config = await loadConfig();
+      if (!id) {
+        console.log();
+        console.log(chalk.bold.cyan("  Create Agent"));
+        console.log(chalk.dim("  Fill in the details below. Press Ctrl+C to cancel.\n"));
+        const answers = await prompts([
+          {
+            type: "text",
+            name: "agentId",
+            message: "Agent ID",
+            validate: (v) => v.length > 0 ? true : "Agent ID is required"
+          },
+          {
+            type: "text",
+            name: "workspace",
+            message: "Workspace directory (optional, press Enter to skip)"
+          },
+          {
+            type: "text",
+            name: "model",
+            message: "Primary model",
+            initial: "anthropic/claude-sonnet-4-5"
+          },
+          {
+            type: "text",
+            name: "name",
+            message: "Display name (optional)"
+          },
+          {
+            type: "text",
+            name: "theme",
+            message: "Persona / theme (optional)"
+          },
+          {
+            type: "confirm",
+            name: "isDefault",
+            message: "Set as default agent?",
+            initial: false
+          }
+        ]);
+        if (!answers.agentId) {
+          warn("Agent creation cancelled.");
+          return;
+        }
+        id = answers.agentId;
+        options.workspace = answers.workspace || void 0;
+        options.model = answers.model || void 0;
+        options.name = answers.name || void 0;
+        options.theme = answers.theme || void 0;
+        options.default = answers.isDefault ?? false;
+      }
+      const connectSpinner = spinner("Connecting to SDK");
+      const { sdk, sdkName } = await createSDK(config);
+      connectSpinner.succeed(`Connected to ${sdkName}`);
+      const createSpinner = spinner(`Creating agent ${chalk.bold(id)}`);
+      try {
+        const created = await sdk.agents.create({
+          agentId: id,
+          workspace: options.workspace,
+          isDefault: options.default ?? false,
+          identity: options.name || options.theme ? { name: options.name, theme: options.theme } : void 0,
+          model: options.model ? { primary: options.model } : void 0
+        });
+        createSpinner.succeed(`Agent ${chalk.bold(created.agentId || id)} created`);
+      } catch (err) {
+        createSpinner.fail(`Failed to create agent: ${err?.message || err}`);
+        sdk.disconnect();
+        process.exitCode = 1;
+        return;
+      }
+      sdk.disconnect();
+    } catch (err) {
+      error(`${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  agent.command("remove").description("Remove an agent").argument("<id>", "Agent ID to remove").action(async (id) => {
+    try {
+      const config = await loadConfig();
+      const connectSpinner = spinner("Connecting to SDK");
+      const { sdk, sdkName } = await createSDK(config);
+      connectSpinner.succeed(`Connected to ${sdkName}`);
+      const removeSpinner = spinner(`Removing agent ${chalk.bold(id)}`);
+      try {
+        await sdk.agents.delete(id);
+        removeSpinner.succeed(`Agent ${chalk.bold(id)} removed`);
+      } catch (err) {
+        removeSpinner.fail(`Failed to remove agent: ${err?.message || err}`);
+        sdk.disconnect();
+        process.exitCode = 1;
+        return;
+      }
+      if (config.agent?.moltAgentId === id) {
+        const manager = new ConfigManager();
+        await manager.load();
+        await manager.set("agent.moltAgentId", "");
+        info("Cleared configured agent ID (was the removed agent).");
+      }
+      sdk.disconnect();
+    } catch (err) {
+      error(`${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  agent.command("stop").description("Stop an agent (disables heartbeat)").argument("<id>", "Agent ID to stop").action(async (id) => {
+    try {
+      const config = await loadConfig();
+      const connectSpinner = spinner("Connecting to SDK");
+      const { sdk, sdkName } = await createSDK(config);
+      connectSpinner.succeed(`Connected to ${sdkName}`);
+      const stopSpinner = spinner(`Stopping agent ${chalk.bold(id)}`);
+      try {
+        await sdk.agents.configureHeartbeat(id, { enabled: false });
+        stopSpinner.succeed(`Agent ${chalk.bold(id)} stopped (heartbeat disabled)`);
+      } catch (err) {
+        stopSpinner.fail(`Failed to stop agent: ${err?.message || err}`);
+        sdk.disconnect();
+        process.exitCode = 1;
+        return;
+      }
+      sdk.disconnect();
+    } catch (err) {
+      error(`${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  agent.command("assign").description("Assign an available agent for task execution").argument("[id]", "Specific agent ID to assign (auto-selects if omitted)").option("-r, --role <role>", "Role to assign", "developer").action(async (id, options) => {
+    try {
+      const config = await loadConfig();
+      const connectSpinner = spinner("Connecting to SDK");
+      const { sdk, sdkName } = await createSDK(config);
+      connectSpinner.succeed(`Connected to ${sdkName}`);
+      const listSpinner = spinner("Fetching agents");
+      const result = await sdk.agents.list();
+      listSpinner.stop();
+      const agents = result.agents ?? [];
+      if (agents.length === 0) {
+        error("No agents available.");
+        info(`Run ${chalk.cyan("moxxy agent create <id>")} to create one first.`);
+        sdk.disconnect();
+        process.exitCode = 1;
+        return;
+      }
+      section(`Available agents (${agents.length})`);
+      for (const a of agents) {
+        const agentId = a.agentId || a.id;
+        const tags = [];
+        if (a.isDefault) tags.push(chalk.cyan("default"));
+        const tagStr = tags.length > 0 ? ` ${tags.join(" ")}` : "";
+        listItem(`${chalk.bold(agentId)}${tagStr}`);
+      }
+      console.log();
+      let targetId;
+      if (id) {
+        const found = agents.find((a) => (a.agentId || a.id) === id);
+        if (!found) {
+          error(`Agent '${id}' not found.`);
+          sdk.disconnect();
+          process.exitCode = 1;
+          return;
+        }
+        targetId = id;
+      } else {
+        const defaultAgent = result.defaultAgentId ? agents.find((a) => (a.agentId || a.id) === result.defaultAgentId) : null;
+        if (defaultAgent) {
+          targetId = defaultAgent.agentId || defaultAgent.id;
+        } else {
+          targetId = agents[0].agentId || agents[0].id;
+        }
+      }
+      const { MoltAgentSupervisor } = await import("./dist-7LTHRYKA.mjs");
+      const supervisor = new MoltAgentSupervisor(sdk);
+      const assignSpinner = spinner(
+        `Assigning agent ${chalk.bold(targetId)} as ${chalk.cyan(options.role)}`
+      );
+      try {
+        const handle = await supervisor.assignAgent(targetId, options.role);
+        if (handle.status === "busy") {
+          assignSpinner.warn(
+            `Agent ${chalk.bold(targetId)} is currently busy. It will be used when it becomes free.`
+          );
+        } else {
+          assignSpinner.succeed(
+            `Agent ${chalk.bold(targetId)} assigned (${chalk.green(handle.status)})`
+          );
+        }
+      } catch (err) {
+        assignSpinner.fail(`Failed to assign agent: ${err?.message || err}`);
+        sdk.disconnect();
+        process.exitCode = 1;
+        return;
+      }
+      const manager = new ConfigManager();
+      await manager.load();
+      await manager.set("agent", {
+        moltAgentId: targetId,
+        maxConcurrentTasks: config.agent?.maxConcurrentTasks || 1
+      });
+      success(
+        `Config updated: ${chalk.bold("agent.moltAgentId")} = ${chalk.cyan(targetId)}`
+      );
+      await supervisor.releaseAgent(targetId);
+      sdk.disconnect();
+    } catch (err) {
+      error(`${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/utils/prompt.ts
+import chalk2 from "chalk";
+import prompts2 from "prompts";
+async function interactiveInit() {
+  console.log();
+  console.log(chalk2.bold.cyan("  Moxxy Config Setup"));
+  console.log(chalk2.dim("  Answer the prompts below to initialize your configuration.\n"));
+  const { sdk } = await prompts2({
+    type: "select",
+    name: "sdk",
+    message: "SDK provider",
+    choices: [
+      { title: "Molt", value: "molt" },
+      { title: "Claude", value: "claude" }
+    ]
+  });
+  if (!sdk) return null;
+  let gatewayUrl;
+  let authToken;
+  let claudeApiKey;
+  let claudeModel;
+  let claudeCliPath;
+  if (sdk === "molt") {
+    const molt = await prompts2([
+      {
+        type: "text",
+        name: "gatewayUrl",
+        message: "Gateway URL",
+        validate: (v) => v.length > 0 ? true : "Gateway URL is required"
+      },
+      {
+        type: "text",
+        name: "authToken",
+        message: "Auth token (optional, press Enter to skip)"
+      }
+    ]);
+    if (!molt.gatewayUrl) return null;
+    gatewayUrl = molt.gatewayUrl;
+    authToken = molt.authToken || void 0;
+  } else {
+    const claude = await prompts2([
+      {
+        type: "text",
+        name: "apiKey",
+        message: "Anthropic API key (optional, press Enter to skip)"
+      },
+      {
+        type: "text",
+        name: "model",
+        message: "Claude model",
+        initial: "claude-sonnet-4-5"
+      },
+      {
+        type: "text",
+        name: "cliPath",
+        message: "Claude CLI path",
+        initial: "claude"
+      }
+    ]);
+    if (claude.model === void 0) return null;
+    claudeApiKey = claude.apiKey || void 0;
+    claudeModel = claude.model;
+    claudeCliPath = claude.cliPath;
+  }
+  const shared = await prompts2([
+    {
+      type: "password",
+      name: "githubToken",
+      message: "GitHub personal access token",
+      validate: (v) => v.length > 0 ? true : "GitHub token is required"
+    },
+    {
+      type: "password",
+      name: "webhookSecret",
+      message: "Webhook secret (optional, press Enter to skip)"
+    },
+    {
+      type: "number",
+      name: "webhookPort",
+      message: "Webhook port",
+      initial: 3456
+    },
+    {
+      type: "text",
+      name: "agentId",
+      message: "Agent ID (optional, press Enter to skip)"
+    }
+  ]);
+  if (!shared.githubToken) return null;
+  const { pipelineStages } = await prompts2({
+    type: "multiselect",
+    name: "pipelineStages",
+    message: "Pipeline stages to enable",
+    choices: [
+      { title: "Triage", value: "triage", selected: true },
+      { title: "Research", value: "research", selected: true },
+      { title: "Inspect", value: "inspect", selected: true },
+      { title: "Plan", value: "plan", selected: true },
+      { title: "Implement", value: "implement", selected: true }
+    ],
+    hint: "- Space to toggle. Plan & Implement are always on."
+  });
+  return {
+    sdk,
+    gatewayUrl,
+    authToken,
+    claudeApiKey,
+    claudeModel,
+    claudeCliPath,
+    githubToken: shared.githubToken,
+    webhookSecret: shared.webhookSecret || void 0,
+    webhookPort: String(shared.webhookPort ?? 3456),
+    agentId: shared.agentId || void 0,
+    pipelineStages: pipelineStages?.length ? pipelineStages : void 0
+  };
+}
+var CONFIG_GROUPS = [
+  { title: "SDK Provider", value: "sdk" },
+  { title: "GitHub", value: "github" },
+  { title: "Webhook", value: "webhook" },
+  { title: "Pipeline Stages", value: "pipeline" },
+  { title: "Agent", value: "agent" },
+  { title: "Done", value: "done" }
+];
+async function interactiveConfig(manager) {
+  const config = manager.getConfig();
+  console.log();
+  console.log(chalk2.bold.cyan("  Moxxy Config Editor"));
+  console.log(chalk2.dim('  Select a section to edit. Ctrl+C or "Done" to exit.\n'));
+  while (true) {
+    const { group } = await prompts2({
+      type: "select",
+      name: "group",
+      message: "Config section",
+      choices: [...CONFIG_GROUPS]
+    });
+    if (!group || group === "done") break;
+    switch (group) {
+      case "sdk":
+        await editSDK(manager, config);
+        break;
+      case "github":
+        await editGitHub(manager, config);
+        break;
+      case "webhook":
+        await editWebhook(manager, config);
+        break;
+      case "pipeline":
+        await editPipeline(manager, config);
+        break;
+      case "agent":
+        await editAgent(manager, config);
+        break;
+    }
+  }
+}
+async function editSDK(manager, config) {
+  const { provider } = await prompts2({
+    type: "select",
+    name: "provider",
+    message: "SDK provider",
+    choices: [
+      { title: "Molt", value: "molt" },
+      { title: "Claude", value: "claude" }
+    ],
+    initial: config.sdk === "claude" ? 1 : 0
+  });
+  if (!provider) return;
+  if (provider === "molt") {
+    const result = await prompts2([
+      {
+        type: "text",
+        name: "gatewayUrl",
+        message: "Gateway URL",
+        initial: config.gateway?.url || ""
+      },
+      {
+        type: "text",
+        name: "authToken",
+        message: "Auth token",
+        initial: config.gateway?.authToken || ""
+      }
+    ]);
+    if (result.gatewayUrl === void 0) return;
+    await manager.set("sdk", "molt");
+    await manager.set("gateway", {
+      url: result.gatewayUrl,
+      authToken: result.authToken || void 0
+    });
+  } else {
+    const result = await prompts2([
+      {
+        type: "text",
+        name: "apiKey",
+        message: "API key",
+        initial: config.claude?.apiKey || ""
+      },
+      {
+        type: "text",
+        name: "model",
+        message: "Model",
+        initial: config.claude?.model || "claude-sonnet-4-5"
+      },
+      {
+        type: "text",
+        name: "cliPath",
+        message: "CLI path",
+        initial: config.claude?.cliPath || "claude"
+      }
+    ]);
+    if (result.model === void 0) return;
+    await manager.set("sdk", "claude");
+    await manager.set("claude", {
+      apiKey: result.apiKey || void 0,
+      model: result.model,
+      cliPath: result.cliPath
+    });
+  }
+  console.log(chalk2.green("  SDK config updated.\n"));
+}
+async function editGitHub(manager, config) {
+  const result = await prompts2([
+    {
+      type: "password",
+      name: "token",
+      message: "GitHub token",
+      initial: config.github?.token || ""
+    },
+    {
+      type: "password",
+      name: "webhookSecret",
+      message: "Webhook secret",
+      initial: config.github?.webhookSecret || ""
+    }
+  ]);
+  if (result.token === void 0) return;
+  await manager.set("github", {
+    token: result.token,
+    webhookSecret: result.webhookSecret || void 0
+  });
+  console.log(chalk2.green("  GitHub config updated.\n"));
+}
+async function editWebhook(manager, config) {
+  const webhook = config.webhook || { port: 3456, host: "0.0.0.0", path: "/webhook/github" };
+  const result = await prompts2([
+    {
+      type: "number",
+      name: "port",
+      message: "Port",
+      initial: webhook.port
+    },
+    {
+      type: "text",
+      name: "host",
+      message: "Host",
+      initial: webhook.host
+    },
+    {
+      type: "text",
+      name: "path",
+      message: "Path",
+      initial: webhook.path
+    }
+  ]);
+  if (result.port === void 0) return;
+  await manager.set("webhook", {
+    port: result.port,
+    host: result.host,
+    path: result.path
+  });
+  console.log(chalk2.green("  Webhook config updated.\n"));
+}
+async function editPipeline(manager, config) {
+  const currentStages = config.pipeline?.enabledStages ?? [...PIPELINE_STAGES];
+  const currentSet = new Set(currentStages);
+  const { stages } = await prompts2({
+    type: "multiselect",
+    name: "stages",
+    message: "Enabled pipeline stages",
+    choices: PIPELINE_STAGES.map((s) => ({
+      title: s.charAt(0).toUpperCase() + s.slice(1),
+      value: s,
+      selected: currentSet.has(s)
+    })),
+    hint: "- Space to toggle. Plan & Implement are always on."
+  });
+  if (!stages) return;
+  const final = [...stages];
+  if (!final.includes("plan")) final.push("plan");
+  if (!final.includes("implement")) final.push("implement");
+  await manager.set("pipeline", { enabledStages: final });
+  console.log(chalk2.green("  Pipeline config updated.\n"));
+}
+async function editAgent(manager, config) {
+  const agent = config.agent || {};
+  const result = await prompts2([
+    {
+      type: "text",
+      name: "moltAgentId",
+      message: "Agent ID",
+      initial: agent.moltAgentId || ""
+    },
+    {
+      type: "number",
+      name: "maxConcurrentTasks",
+      message: "Max concurrent tasks",
+      initial: agent.maxConcurrentTasks || 1
+    }
+  ]);
+  if (result.moltAgentId === void 0) return;
+  await manager.set("agent", {
+    moltAgentId: result.moltAgentId || void 0,
+    maxConcurrentTasks: result.maxConcurrentTasks || 1
+  });
+  console.log(chalk2.green("  Agent config updated.\n"));
+}
+
+// src/commands/config.ts
+function registerConfigCommand(program) {
+  const config = program.command("config").description("Manage Moxxy configuration");
+  config.action(async () => {
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+    } catch {
+      error("No config found. Run 'moxxy config init' first.");
+      process.exitCode = 1;
+      return;
+    }
+    await interactiveConfig(manager);
+  });
+  config.command("init").description("Initialize Moxxy configuration").option("--sdk <provider>", "SDK provider (molt or claude)").option("--github-token <token>", "GitHub personal access token").option("--gateway-url <url>", "Gateway URL (molt SDK)").option("--auth-token <token>", "Gateway auth token (molt SDK)").option("--claude-api-key <key>", "Anthropic API key (claude SDK)").option("--claude-model <model>", "Claude model (claude SDK)", "claude-sonnet-4-5").option("--claude-cli-path <path>", "Claude CLI path (claude SDK)", "claude").option("--webhook-secret <secret>", "GitHub webhook secret").option("--webhook-port <port>", "Webhook server port", "3456").option("--agent-id <id>", "Agent ID").option(
+    "--pipeline-stages <stages>",
+    "Comma-separated pipeline stages (triage,research,inspect,plan,implement)"
+  ).action(async (options) => {
+    if (!options.sdk) {
+      const result = await interactiveInit();
+      if (!result) {
+        warn("Config init cancelled.");
+        return;
+      }
+      options = { ...options, ...result };
+    }
+    const sdk = options.sdk;
+    if (sdk !== "molt" && sdk !== "claude") {
+      error('--sdk must be "molt" or "claude"');
+      process.exitCode = 1;
+      return;
+    }
+    if (!options.githubToken) {
+      error("--github-token is required");
+      process.exitCode = 1;
+      return;
+    }
+    if (sdk === "molt" && !options.gatewayUrl) {
+      error("--gateway-url is required when using the molt SDK");
+      process.exitCode = 1;
+      return;
+    }
+    let enabledStages;
+    if (options.pipelineStages) {
+      if (typeof options.pipelineStages === "string") {
+        enabledStages = options.pipelineStages.split(",").map((s) => s.trim());
+      } else if (Array.isArray(options.pipelineStages)) {
+        enabledStages = options.pipelineStages;
+      }
+    }
+    const manager = new ConfigManager();
+    try {
+      await manager.init({
+        version: 1,
+        sdk,
+        gateway: sdk === "molt" ? { url: options.gatewayUrl, authToken: options.authToken } : void 0,
+        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,
+        pipeline: enabledStages ? { enabledStages } : void 0,
+        claude: sdk === "claude" ? {
+          apiKey: options.claudeApiKey,
+          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/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/start.ts
+var SDK_NAMES2 = {
+  molt: "Molt Gateway",
+  claude: "Claude CLI"
+};
+async function createSDK2(config) {
+  const provider = config.sdk || "molt";
+  const sdkName = SDK_NAMES2[provider] || provider;
+  if (provider === "claude") {
+    const { ClaudeSDK } = await import("./src-D5HMDDVE.mjs");
+    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 };
+  }
+  if (!config.gateway) {
+    throw new Error(
+      'Gateway configuration is required for the molt SDK. Run "moxxy config init --sdk molt --gateway-url <url>".'
+    );
+  }
+  const { MoltSDK } = await import("./dist-UYA4RJUH.mjs");
+  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("./dist-7LTHRYKA.mjs");
+      const { IntegrationManager } = await import("./dist-LKIOZQ42.mjs");
+      const { GitHubIntegration } = await import("./dist-KLSB6YHV.mjs");
+      const provider = config.sdk || "molt";
+      const sdkName = SDK_NAMES2[provider] || provider;
+      const connectSpinner = spinner(`Connecting to ${sdkName}`);
+      try {
+        const { sdk } = await createSDK2(config);
+        connectSpinner.succeed(`Connected to ${sdkName}`);
+        const supervisorSpinner = spinner("Initializing agent supervisor");
+        const supervisor = new MoltAgentSupervisor(sdk);
+        let agentId = config.agent?.moltAgentId;
+        if (!agentId) {
+          const agentList = await sdk.agents.list();
+          const agents = agentList.agents ?? [];
+          if (agents.length > 0) {
+            const picked = agentList.defaultAgentId && agents.find((a) => (a.agentId || a.id) === agentList.defaultAgentId) || agents[0];
+            agentId = picked.agentId || picked.id;
+          }
+        }
+        if (agentId) {
+          await supervisor.assignAgent(agentId, "developer");
+          supervisorSpinner.succeed(`Agent ${chalk.bold(agentId)} assigned`);
+        } else {
+          supervisorSpinner.warn(
+            `No agents found. Run ${chalk.cyan("moxxy agent create <id>")} to create one.`
+          );
+        }
+        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 || "",
+          enabledStages: config.pipeline?.enabledStages
+        });
+        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`);
+          await github.watchRepos(config.repos);
+          const targets = config.repos.map((r) => `${r.owner}/${r.repo}`);
+          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/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" && config.gateway) {
+        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(
+          "API Key",
+          config.claude.apiKey ? chalk.yellow("***" + config.claude.apiKey.slice(-4)) : chalk.dim("not set")
+        );
+        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("0.0.6");
+  registerStartCommand(program);
+  registerRepoCommand(program);
+  registerConfigCommand(program);
+  registerStatusCommand(program);
+  registerAgentCommand(program);
+  return program;
+}
+
+export {
+  ConfigManager,
+  createProgram
+};