@moxxy/cli 0.0.12 → 0.1.0

package/src/api-client.js

@@ -0,0 +1,286 @@
+const GATEWAY_DOWN_MSG = 'Gateway is not running. Start it with: moxxy gateway start';
+
+function isConnectionError(err) {
+  const cause = err.cause;
+  if (cause && (cause.code === 'ECONNREFUSED' || cause.code === 'ECONNRESET')) return true;
+  const msg = (err.message || '').toLowerCase();
+  return msg.includes('econnrefused') || msg.includes('fetch failed')
+    || msg.includes('unable to connect') || msg.includes('connection refused');
+}
+
+function gatewayDownError() {
+  const error = new Error(GATEWAY_DOWN_MSG);
+  error.isGatewayDown = true;
+  return error;
+}
+
+function normalizeBaseUrl(baseUrl) {
+  const raw = (baseUrl || '').trim();
+  if (!raw) return 'http://localhost:3000';
+  const withoutTrailingSlash = raw.replace(/\/+$/, '');
+  const withoutV1Suffix = withoutTrailingSlash.replace(/\/v1$/i, '');
+  return withoutV1Suffix || withoutTrailingSlash;
+}
+
+function normalizeMcpServersResponse(payload) {
+  if (Array.isArray(payload)) return payload;
+  if (Array.isArray(payload?.servers)) return payload.servers;
+  return [];
+}
+
+/**
+ * Moxxy API client.
+ * Uses native fetch with bearer token injection.
+ */
+export class ApiClient {
+  constructor(baseUrl, token, authMode = 'token') {
+    this.baseUrl = normalizeBaseUrl(baseUrl);
+    this.token = token;
+    this.authMode = authMode;
+  }
+
+  buildUrl(path) {
+    return `${this.baseUrl}${path}`;
+  }
+
+  buildRequest(path, method, body) {
+    const headers = {
+      'content-type': 'application/json',
+    };
+    if (this.token) {
+      headers['authorization'] = `Bearer ${this.token}`;
+    }
+    return new Request(this.buildUrl(path), {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+  }
+
+  async request(path, method, body) {
+    const req = this.buildRequest(path, method, body);
+    let resp;
+    try {
+      resp = await fetch(req);
+    } catch (err) {
+      if (isConnectionError(err)) throw gatewayDownError();
+      throw err;
+    }
+    if (!resp.ok) {
+      const err = await resp.json().catch(() => ({
+        error: 'unknown',
+        message: resp.statusText,
+      }));
+      let msg = err.message || `API error ${resp.status}`;
+      if (resp.status === 401 && this.authMode === 'loopback') {
+        msg += '\nLoopback mode is enabled but the gateway rejected the request. Ensure the gateway is running with auth_mode: loopback.';
+      } else if (resp.status === 401 && !this.token) {
+        msg += '\nMOXXY_TOKEN is not set. Run `moxxy init` to create a token, or set it with:\n  export MOXXY_TOKEN="<your-token>"';
+      } else if (resp.status === 401) {
+        msg += '\nYour token may be expired or revoked. Create a new one with: moxxy auth token create';
+      } else if (resp.status === 404) {
+        msg += `\nEndpoint not found (${path}). Verify MOXXY_API_URL points to a Moxxy gateway with /v1 routes.`;
+      }
+      const error = new Error(msg);
+      error.status = resp.status;
+      throw error;
+    }
+    const text = await resp.text();
+    if (!text) return {};
+    return JSON.parse(text);
+  }
+
+  async createToken(scopes, ttlSeconds, description) {
+    const body = { scopes };
+    if (ttlSeconds !== undefined && ttlSeconds !== null) body.ttl_seconds = ttlSeconds;
+    if (description) body.description = description;
+    return this.request('/v1/auth/tokens', 'POST', body);
+  }
+
+  async listTokens() {
+    return this.request('/v1/auth/tokens', 'GET');
+  }
+
+  async revokeToken(id) {
+    return this.request(`/v1/auth/tokens/${encodeURIComponent(id)}`, 'DELETE');
+  }
+
+  async createAgent(providerId, modelId, name, opts = {}) {
+    const body = {
+      provider_id: providerId,
+      model_id: modelId,
+      name,
+      ...opts,
+    };
+    return this.request('/v1/agents', 'POST', body);
+  }
+
+  async getAgent(id) {
+    return this.request(`/v1/agents/${encodeURIComponent(id)}`, 'GET');
+  }
+
+  async updateAgent(id, updates) {
+    return this.request(`/v1/agents/${encodeURIComponent(id)}`, 'PATCH', updates);
+  }
+
+  async startRun(agentId, task) {
+    return this.request(`/v1/agents/${encodeURIComponent(agentId)}/runs`, 'POST', { task });
+  }
+
+  async stopAgent(agentId) {
+    return this.request(`/v1/agents/${encodeURIComponent(agentId)}/stop`, 'POST');
+  }
+
+  async resetSession(agentId) {
+    return this.request(`/v1/agents/${encodeURIComponent(agentId)}/reset`, 'POST');
+  }
+
+  async deleteAgent(agentId) {
+    return this.request(`/v1/agents/${encodeURIComponent(agentId)}`, 'DELETE');
+  }
+
+  eventStreamUrl(filters = {}) {
+    const url = new URL('/v1/events/stream', this.baseUrl);
+    for (const [k, v] of Object.entries(filters)) {
+      if (v) url.searchParams.set(k, v);
+    }
+    return url.toString();
+  }
+
+  async getHistory(agentId, limit = 50) {
+    return this.request(`/v1/agents/${encodeURIComponent(agentId)}/history?limit=${limit}`, 'GET');
+  }
+
+  async listAgents() {
+    return this.request('/v1/agents', 'GET');
+  }
+
+  async listProviders() {
+    return this.request('/v1/providers', 'GET');
+  }
+
+  async listModels(providerId) {
+    return this.request(`/v1/providers/${encodeURIComponent(providerId)}/models`, 'GET');
+  }
+
+  async listSecrets() {
+    return this.request('/v1/vault/secrets', 'GET');
+  }
+
+  async createSecret(body) {
+    return this.request('/v1/vault/secrets', 'POST', body);
+  }
+
+  async deleteSecret(id) {
+    return this.request(`/v1/vault/secrets/${encodeURIComponent(id)}`, 'DELETE');
+  }
+
+  async respondToAsk(agentId, questionId, answer) {
+    return this.request(
+      `/v1/agents/${encodeURIComponent(agentId)}/ask-responses/${encodeURIComponent(questionId)}`,
+      'POST',
+      { answer },
+    );
+  }
+
+  async listSkills(agentId) {
+    return this.request(`/v1/agents/${encodeURIComponent(agentId)}/skills`, 'GET');
+  }
+
+  async deleteSkill(agentId, skillId) {
+    return this.request(`/v1/agents/${encodeURIComponent(agentId)}/skills/${encodeURIComponent(skillId)}`, 'DELETE');
+  }
+
+  async disableHeartbeat(agentId, heartbeatId) {
+    return this.request(`/v1/agents/${encodeURIComponent(agentId)}/heartbeats/${encodeURIComponent(heartbeatId)}`, 'DELETE');
+  }
+
+  async listGrants() {
+    return this.request('/v1/vault/grants', 'GET');
+  }
+
+  async revokeGrant(grantId) {
+    return this.request(`/v1/vault/grants/${encodeURIComponent(grantId)}`, 'DELETE');
+  }
+
+  async installProvider(id, displayName, models) {
+    return this.request('/v1/providers', 'POST', {
+      id,
+      display_name: displayName,
+      models,
+    });
+  }
+
+  async listChannels() {
+    return this.request('/v1/channels', 'GET');
+  }
+
+  async createChannel(channelType, displayName, botToken, config) {
+    return this.request('/v1/channels', 'POST', {
+      channel_type: channelType,
+      display_name: displayName,
+      bot_token: botToken,
+      config,
+    });
+  }
+
+  async pairChannel(channelId, code, agentId) {
+    return this.request(`/v1/channels/${encodeURIComponent(channelId)}/pair`, 'POST', {
+      code,
+      agent_id: agentId,
+    });
+  }
+
+  async deleteChannel(channelId) {
+    return this.request(`/v1/channels/${encodeURIComponent(channelId)}`, 'DELETE');
+  }
+
+  async listChannelBindings(channelId) {
+    return this.request(`/v1/channels/${encodeURIComponent(channelId)}/bindings`, 'GET');
+  }
+
+  async listMcpServers(agentName) {
+    const payload = await this.request(`/v1/agents/${encodeURIComponent(agentName)}/mcp`, 'GET');
+    return normalizeMcpServersResponse(payload);
+  }
+
+  async addMcpServer(agentName, config) {
+    return this.request(`/v1/agents/${encodeURIComponent(agentName)}/mcp`, 'POST', config);
+  }
+
+  async removeMcpServer(agentName, serverId) {
+    return this.request(`/v1/agents/${encodeURIComponent(agentName)}/mcp/${encodeURIComponent(serverId)}`, 'DELETE');
+  }
+
+  async testMcpServer(agentName, serverId) {
+    return this.request(`/v1/agents/${encodeURIComponent(agentName)}/mcp/${encodeURIComponent(serverId)}/test`, 'POST');
+  }
+
+  async listTemplates() {
+    return this.request('/v1/templates', 'GET');
+  }
+
+  async getTemplate(slug) {
+    return this.request(`/v1/templates/${encodeURIComponent(slug)}`, 'GET');
+  }
+
+  async createTemplate(content) {
+    return this.request('/v1/templates', 'POST', { content });
+  }
+
+  async updateTemplate(slug, content) {
+    return this.request(`/v1/templates/${encodeURIComponent(slug)}`, 'PUT', { content });
+  }
+
+  async deleteTemplate(slug) {
+    return this.request(`/v1/templates/${encodeURIComponent(slug)}`, 'DELETE');
+  }
+
+  async setAgentTemplate(name, template) {
+    return this.request(`/v1/agents/${encodeURIComponent(name)}/template`, 'PATCH', { template });
+  }
+}
+
+export function createApiClient(baseUrl, token, authMode = 'token') {
+  return new ApiClient(baseUrl, token, authMode);
+}

package/src/cli.js

@@ -0,0 +1,341 @@
+import { createApiClient } from './api-client.js';
+import { isInteractive, CancelledError, p } from './ui.js';
+import { runInit, readAuthMode } from './commands/init.js';
+import { runGateway } from './commands/gateway.js';
+import { runAuth } from './commands/auth.js';
+import { runProvider } from './commands/provider.js';
+import { runAgent } from './commands/agent.js';
+import { runSkill } from './commands/skill.js';
+import { runTemplate } from './commands/template.js';
+import { runVault } from './commands/vault.js';
+import { runHeartbeat } from './commands/heartbeat.js';
+import { runChannel } from './commands/channel.js';
+import { runMcp } from './commands/mcp.js';
+import { runEvents } from './commands/events.js';
+import { runDoctor } from './commands/doctor.js';
+import { runUpdate } from './commands/update.js';
+import { runUninstall } from './commands/uninstall.js';
+import { runPlugin } from './commands/plugin.js';
+import { COMMAND_HELP, showHelp } from './help.js';
+import chalk from 'chalk';
+import { createInterface, cursorTo, clearScreenDown } from 'node:readline';
+import pkg from '../package.json' with { type: 'json' };
+
+const { version } = pkg;
+
+export const LOGO = `\n\n\n\n\n
+  ███╗   ███╗ ██████╗ ██╗  ██╗██╗  ██╗██╗   ██╗
+  ████╗ ████║██╔═══██╗╚██╗██╔╝╚██╗██╔╝╚██╗ ██╔╝
+  ██╔████╔██║██║   ██║ ╚███╔╝  ╚███╔╝  ╚████╔╝
+  ██║╚██╔╝██║██║   ██║ ██╔██╗  ██╔██╗   ╚██╔╝
+  ██║ ╚═╝ ██║╚██████╔╝██╔╝ ██╗██╔╝ ██╗   ██║
+  ╚═╝     ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝
+  ${chalk.italic.dim('Agents that work while you sleep.')}  ${chalk.gray(`v${version}`)}
+`;
+
+const HELP = `${LOGO}
+  Agentic Framework CLI
+
+Usage:
+  moxxy                                               Interactive menu
+  moxxy init                                          First-time setup wizard
+  moxxy gateway start                                Start the gateway
+  moxxy gateway stop                                 Stop the gateway
+  moxxy gateway restart                              Restart the gateway
+  moxxy gateway status                               Show gateway status
+  moxxy gateway logs                                 Tail gateway logs
+  moxxy auth token create [--scopes <s>] [--ttl <n>] [--json]
+  moxxy auth token list [--json]
+  moxxy auth token revoke <id>
+  moxxy provider list
+  moxxy provider install --id <provider-id>
+  moxxy provider login --id openai-codex --method browser|headless
+  moxxy agent create --provider <p> --model <m> --workspace <w> [--json]
+  moxxy agent run --id <id> --task "task" [--json]
+  moxxy agent stop --id <id>
+  moxxy agent status --id <id> [--json]
+  moxxy skill create --agent <id> --content <c>
+  moxxy skill list --agent <id>
+  moxxy template list
+  moxxy template get <slug>
+  moxxy template create --content <c>
+  moxxy template remove <slug>
+  moxxy template assign --agent <id> --template <slug>
+  moxxy vault add --key <k> --backend <b>
+  moxxy vault grant --agent <id> --secret <id>
+  moxxy heartbeat set --agent <id> --interval <n> [--action_type <t>]
+  moxxy heartbeat list --agent <id>
+  moxxy channel create                              Create a channel (Telegram/Discord)
+  moxxy channel list                                List channels
+  moxxy channel pair --code <code> --agent <id>     Pair a chat to an agent
+  moxxy channel delete <id>                         Delete a channel
+  moxxy channel bindings <id>                       List bindings for a channel
+  moxxy channel unbind <channel-id> <binding-id>    Unbind a chat
+  moxxy mcp list --agent <name>                     List MCP servers
+  moxxy mcp add --agent <name> --id <id> --transport stdio --command <cmd> [--args ...]
+  moxxy mcp add --agent <name> --id <id> --transport sse --url <url>
+  moxxy mcp remove --agent <name> --id <id>         Remove an MCP server
+  moxxy mcp test --agent <name> --id <id>           Test an MCP server
+  moxxy plugin list                                  List installed plugins
+  moxxy plugin install <package>                     Install a plugin
+  moxxy plugin start <name>                          Start a plugin
+  moxxy plugin stop <name>                           Stop a plugin
+  moxxy plugin restart <name>                        Restart a plugin
+  moxxy plugin update <name>                         Update a plugin to latest
+  moxxy plugin uninstall <name>                      Remove a plugin
+  moxxy plugin logs <name>                           Tail plugin logs
+  moxxy tui [--agent <id>]                            Full-screen chat interface
+  moxxy chat [--agent <id>]                           Alias for tui
+  moxxy events tail [--agent <id>] [--run <id>] [--json]
+  moxxy doctor                                       Diagnose installation
+  moxxy update [--check] [--force] [--json]          Check for and install updates
+  moxxy update --rollback                            Restore previous gateway version
+  moxxy uninstall                                    Remove all Moxxy data
+
+Environment:
+  MOXXY_API_URL   API base URL (default: http://localhost:3000)
+  MOXXY_TOKEN     API token for authentication
+`.trim();
+
+
+export function clearScreen() {
+  if (!isInteractive()) return;
+  const rows = process.stdout.rows - 2;
+  const blank = rows > 0 ? '\n'.repeat(rows) : '';
+  console.log(blank);
+  cursorTo(process.stdout, 0, 0);
+  clearScreenDown(process.stdout);
+}
+
+function waitForEnter() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question(chalk.dim('\n  Press Enter to continue… '), () => {
+      rl.close();
+      resolve();
+    });
+  });
+}
+
+function hasHelpFlag(args) {
+  return args.includes('--help') || args.includes('-h');
+}
+
+async function routeCommand(client, command, rest) {
+  const helpKey = command === 'chat' ? 'tui' : command;
+  if (hasHelpFlag(rest) && COMMAND_HELP[helpKey]) {
+    showHelp(helpKey, p);
+    return;
+  }
+
+  clearScreen();
+  console.log(LOGO);
+
+  switch (command) {
+    case 'init':
+      await runInit(client, rest);
+      break;
+    case 'gateway':
+      await runGateway(client, rest);
+      break;
+    case 'auth':
+      await runAuth(client, rest);
+      break;
+    case 'provider':
+      await runProvider(client, rest);
+      break;
+    case 'agent':
+      await runAgent(client, rest);
+      break;
+    case 'skill':
+      await runSkill(client, rest);
+      break;
+    case 'template':
+      await runTemplate(client, rest);
+      break;
+    case 'vault':
+      await runVault(client, rest);
+      break;
+    case 'heartbeat':
+      await runHeartbeat(client, rest);
+      break;
+    case 'channel':
+      await runChannel(client, rest);
+      break;
+    case 'mcp':
+      await runMcp(client, rest);
+      break;
+    case 'plugin':
+      await runPlugin(client, rest);
+      break;
+    case 'tui':
+    case 'chat': {
+      const { startTui } = await import('./tui/index.jsx');
+      await startTui(client, rest);
+      break;
+    }
+    case 'events':
+      await runEvents(client, rest);
+      break;
+    case 'doctor':
+      await runDoctor(client, rest);
+      break;
+    case 'update':
+      await runUpdate(client, rest);
+      break;
+    case 'uninstall':
+      await runUninstall(client, rest);
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log(HELP);
+      process.exitCode = 1;
+  }
+}
+
+async function main() {
+  const [,, command, ...rest] = process.argv;
+
+  if (command === '--version' || command === '-V') {
+    console.log(`moxxy v${version}`);
+    return;
+  }
+
+  if (command === 'help' || command === '--help' || command === '-h') {
+    console.log(HELP);
+    return;
+  }
+
+  const baseUrl = process.env.MOXXY_API_URL || 'http://localhost:3000';
+  const authMode = readAuthMode();
+  const token = process.env.MOXXY_TOKEN || '';
+  const client = createApiClient(baseUrl, token, authMode);
+
+  const MENU_GROUPS = {
+    setup:        { label: 'Setup',        hint: 'init, gateway, doctor' },
+    agents:       { label: 'Agents',       hint: 'agents, skills, templates' },
+    security:     { label: 'Security',     hint: 'auth tokens & secrets' },
+    integrations: { label: 'Integrations', hint: 'providers, channels, MCP, plugins' },
+    tools:        { label: 'Tools',        hint: 'events stream' },
+    system:       { label: 'System',       hint: 'update & uninstall' },
+  };
+
+  const SUBMENUS = {
+    setup: [
+      { value: 'init',      label: 'Init',      hint: 'first-time setup' },
+      { value: 'gateway',   label: 'Gateway',   hint: 'start/stop/manage gateway' },
+      { value: 'doctor',    label: 'Doctor',    hint: 'diagnose installation' },
+    ],
+    agents: [
+      { value: 'agent',     label: 'Agent',     hint: 'create & manage agents' },
+      { value: 'skill',     label: 'Skill',     hint: 'create & manage skills' },
+      { value: 'template',  label: 'Template',  hint: 'manage agent templates' },
+    ],
+    security: [
+      { value: 'auth',      label: 'Auth',      hint: 'manage API tokens' },
+      { value: 'vault',     label: 'Vault',     hint: 'manage secrets' },
+    ],
+    integrations: [
+      { value: 'provider',  label: 'Provider',  hint: 'list providers' },
+      { value: 'channel',   label: 'Channel',   hint: 'manage Telegram/Discord channels' },
+      { value: 'mcp',       label: 'MCP',       hint: 'manage MCP servers for agents' },
+      { value: 'plugin',    label: 'Plugin',    hint: 'manage plugins & extensions' },
+      { value: 'heartbeat', label: 'Heartbeat', hint: 'schedule heartbeat rules' },
+    ],
+    tools: [
+      { value: 'events',    label: 'Events',    hint: 'stream live events' },
+    ],
+    system: [
+      { value: 'update',    label: 'Update',    hint: 'check for and install updates' },
+      { value: 'uninstall', label: 'Uninstall', hint: 'remove all Moxxy data' },
+    ],
+  };
+
+  if (!command && isInteractive()) {
+    while (true) {
+      clearScreen();
+      console.log(LOGO);
+      p.intro();
+
+      const selected = await p.select({
+        message: 'What would you like to do?',
+        options: [
+          { value: 'tui', label: 'Chat', hint: 'full-screen TUI' },
+          ...Object.entries(MENU_GROUPS).map(([key, { label, hint }]) => ({
+            value: key, label, hint,
+          })),
+        ],
+      });
+
+      if (p.isCancel(selected)) {
+        p.cancel('Goodbye.');
+        break;
+      }
+
+      // Chat goes straight to the command
+      if (selected === 'tui') {
+        try {
+          await routeCommand(client, 'tui', []);
+          continue;
+        } catch (err) {
+          if (err instanceof CancelledError) continue;
+          if (err.isGatewayDown) p.log.info(err.message);
+          else p.log.error(err.message);
+          await waitForEnter();
+          process.exitCode = 1;
+          continue;
+        }
+      }
+
+      const submenu = SUBMENUS[selected];
+      if (!submenu) continue;
+
+      const subSelected = await p.select({
+        message: `${MENU_GROUPS[selected].label}`,
+        options: submenu,
+      });
+
+      if (p.isCancel(subSelected)) {
+        continue;
+      }
+
+      try {
+        await routeCommand(client, subSelected, []);
+        await waitForEnter();
+      } catch (err) {
+        if (err instanceof CancelledError) {
+          continue;
+        }
+        if (err.isGatewayDown) {
+          p.log.info(err.message);
+        } else {
+          p.log.error(err.message);
+        }
+        await waitForEnter();
+        process.exitCode = 1;
+      }
+    }
+    return;
+  }
+
+  if (!command) {
+    console.log(HELP);
+    return;
+  }
+
+  try {
+    await routeCommand(client, command, rest);
+  } catch (err) {
+    if (err instanceof CancelledError) {
+      return;
+    }
+    if (err.isGatewayDown) {
+      console.log(err.message);
+    } else {
+      console.error(`Error: ${err.message}`);
+    }
+    process.exitCode = 1;
+  }
+}
+
+main();