@moxxy/cli 0.0.1 → 0.0.3

package/README.md

@@ -0,0 +1,91 @@
+# @moxxy/cli
+
+User-facing CLI for [Moxxy](https://github.com/webeferen/moxxy) agent orchestration.
+
+## Installation
+
+```bash
+npm install -g @moxxy/cli
+```
+
+## Quick Start
+
+```bash
+# Interactive setup — walks you through each config step
+moxxy config init
+
+# Or pass flags directly
+moxxy config init --sdk claude --github-token ghp_xxx
+
+# Add a repository to watch
+moxxy repo add owner/repo --events issues.opened,issues.labeled
+
+# Start orchestration
+moxxy start
+```
+
+## Commands
+
+### `moxxy config init`
+
+Initialize configuration. Launches an interactive wizard when called without flags.
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--sdk <provider>` | `molt` or `claude` | _(interactive)_ |
+| `--github-token <token>` | GitHub personal access token | _(interactive)_ |
+| `--gateway-url <url>` | Molt Gateway URL (molt only) | |
+| `--auth-token <token>` | Molt Gateway auth token | |
+| `--claude-api-key <key>` | Anthropic API key (claude only) | |
+| `--claude-model <model>` | Claude model | `claude-sonnet-4-5` |
+| `--claude-cli-path <path>` | Path to Claude CLI binary | `claude` |
+| `--webhook-secret <secret>` | GitHub webhook secret | |
+| `--webhook-port <port>` | Webhook server port | `3456` |
+| `--agent-id <id>` | Agent ID | |
+
+### `moxxy config set <key> <value>`
+
+Set a config value using dot notation (e.g. `moxxy config set webhook.port 8080`).
+
+### `moxxy config get <key>`
+
+Read a config value using dot notation.
+
+### `moxxy repo add <owner/repo>`
+
+Add a repository to watch.
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--branch <branch>` | Default branch | `main` |
+| `--events <events>` | Comma-separated events | `issues.opened,issues.labeled` |
+
+### `moxxy repo list`
+
+List all configured repositories.
+
+### `moxxy repo remove <owner/repo>`
+
+Remove a repository from the watch list.
+
+### `moxxy start`
+
+Start the orchestration server. Connects to the configured SDK, initializes the agent supervisor, and starts the webhook server to listen for GitHub events on watched repositories.
+
+### `moxxy status`
+
+Display current configuration: SDK provider, GitHub token status, webhook settings, watched repositories, and agent configuration.
+
+## Programmatic Usage
+
+```typescript
+import { createProgram, ConfigManager } from '@moxxy/cli';
+
+const manager = new ConfigManager();
+await manager.load();
+console.log(manager.get('sdk'));
+```
+
+## License
+
+MIT

package/dist/chunk-6DZX6EAA.mjs

@@ -0,0 +1,37 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/chunk-C46NSEKG.mjs

@@ -0,0 +1,211 @@
+// ../integration-base/dist/index.mjs
+var IntegrationError = class extends Error {
+  constructor(message, integration, code, cause) {
+    super(message);
+    this.integration = integration;
+    this.code = code;
+    this.cause = cause;
+    this.name = "IntegrationError";
+  }
+};
+var IntegrationConnectionError = class extends IntegrationError {
+  constructor(message, integration, cause) {
+    super(message, integration, "CONNECTION_ERROR", cause);
+    this.name = "IntegrationConnectionError";
+  }
+};
+var IntegrationConfigError = class extends IntegrationError {
+  constructor(message, integration, cause) {
+    super(message, integration, "CONFIG_ERROR", cause);
+    this.name = "IntegrationConfigError";
+  }
+};
+var IntegrationNotFoundError = class extends IntegrationError {
+  constructor(integration) {
+    super(`Integration "${integration}" not found`, integration, "NOT_FOUND");
+    this.name = "IntegrationNotFoundError";
+  }
+};
+var BaseIntegration = class {
+  constructor(name, type) {
+    this.name = name;
+    this.type = type;
+  }
+  _status = "disconnected";
+  handlers = /* @__PURE__ */ new Map();
+  get status() {
+    return this._status;
+  }
+  async connect(config) {
+    if (this._status === "connected" || this._status === "watching") {
+      return;
+    }
+    this._status = "connecting";
+    try {
+      await this.onConnect(config);
+      this._status = "connected";
+    } catch (error) {
+      this._status = "error";
+      throw new IntegrationConnectionError(
+        `Failed to connect integration "${this.name}": ${error instanceof Error ? error.message : String(error)}`,
+        this.name,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  async disconnect() {
+    if (this._status === "disconnected") {
+      return;
+    }
+    try {
+      await this.onDisconnect();
+    } finally {
+      this._status = "disconnected";
+    }
+  }
+  async watch(targets) {
+    if (this._status !== "connected" && this._status !== "watching") {
+      throw new IntegrationConnectionError(
+        `Cannot watch: integration "${this.name}" is not connected`,
+        this.name
+      );
+    }
+    await this.onWatch(targets);
+    this._status = "watching";
+  }
+  async unwatch(targets) {
+    if (this._status !== "watching") {
+      return;
+    }
+    await this.onUnwatch(targets);
+    this._status = "connected";
+  }
+  async dispose() {
+    if (this._status !== "disconnected") {
+      await this.disconnect();
+    }
+    this.handlers.clear();
+  }
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+  }
+  off(event, handler) {
+    const set = this.handlers.get(event);
+    if (set) {
+      set.delete(handler);
+      if (set.size === 0) {
+        this.handlers.delete(event);
+      }
+    }
+  }
+  emit(type, data) {
+    const event = {
+      type,
+      integration: this.name,
+      data,
+      timestamp: Date.now()
+    };
+    const specificHandlers = this.handlers.get(type);
+    if (specificHandlers) {
+      for (const handler of specificHandlers) {
+        handler(event);
+      }
+    }
+    const wildcardHandlers = this.handlers.get("*");
+    if (wildcardHandlers) {
+      for (const handler of wildcardHandlers) {
+        handler(event);
+      }
+    }
+  }
+};
+var IntegrationManager = class {
+  integrations = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  integrationListeners = /* @__PURE__ */ new Map();
+  register(integration) {
+    this.integrations.set(integration.name, integration);
+    const listener = (event) => {
+      this.emitToHandlers(event);
+    };
+    this.integrationListeners.set(integration.name, listener);
+    integration.on("*", listener);
+  }
+  unregister(name) {
+    const integration = this.integrations.get(name);
+    if (!integration) {
+      return;
+    }
+    const listener = this.integrationListeners.get(name);
+    if (listener) {
+      integration.off("*", listener);
+      this.integrationListeners.delete(name);
+    }
+    this.integrations.delete(name);
+  }
+  get(name) {
+    return this.integrations.get(name);
+  }
+  getAll() {
+    return Array.from(this.integrations.values());
+  }
+  async startAll() {
+    const promises = [];
+    for (const integration of this.integrations.values()) {
+      promises.push(integration.connect({}));
+    }
+    await Promise.all(promises);
+  }
+  async stopAll() {
+    const promises = [];
+    for (const integration of this.integrations.values()) {
+      promises.push(integration.disconnect());
+    }
+    await Promise.all(promises);
+  }
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+  }
+  off(event, handler) {
+    const set = this.handlers.get(event);
+    if (set) {
+      set.delete(handler);
+      if (set.size === 0) {
+        this.handlers.delete(event);
+      }
+    }
+  }
+  emitToHandlers(event) {
+    const specificHandlers = this.handlers.get(event.type);
+    if (specificHandlers) {
+      for (const handler of specificHandlers) {
+        handler(event);
+      }
+    }
+    const wildcardHandlers = this.handlers.get("*");
+    if (wildcardHandlers) {
+      for (const handler of wildcardHandlers) {
+        handler(event);
+      }
+    }
+  }
+};
+
+export {
+  IntegrationError,
+  IntegrationConnectionError,
+  IntegrationConfigError,
+  IntegrationNotFoundError,
+  BaseIntegration,
+  IntegrationManager
+};