@moxxy/cli 0.0.12 → 0.1.1

package/src/commands/doctor.js

@@ -0,0 +1,261 @@
+/**
+ * Doctor command: diagnose the Moxxy installation.
+ * Checks gateway, auth, providers, agents, storage, and environment.
+ */
+import { p, withSpinner } from '../ui.js';
+import { getMoxxyHome } from './init.js';
+import { existsSync, statSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { platform } from 'node:os';
+
+export async function runDoctor(client, args) {
+  p.intro('Moxxy Doctor');
+
+  let pass = 0;
+  let warn = 0;
+  let fail = 0;
+
+  function ok(msg) { p.log.success(msg); pass++; }
+  function warning(msg) { p.log.warn(msg); warn++; }
+  function error(msg) { p.log.error(msg); fail++; }
+
+  // ── 1. Moxxy Home Directory ──
+
+  const moxxyHome = getMoxxyHome();
+  if (existsSync(moxxyHome)) {
+    ok(`Moxxy home exists: ${moxxyHome}`);
+
+    if (existsSync(join(moxxyHome, 'agents'))) {
+      const agents = readdirSync(join(moxxyHome, 'agents'));
+      ok(`Agents directory: ${agents.length} agent(s)`);
+    } else {
+      warning('Agents directory missing. Run: moxxy init');
+    }
+
+    if (existsSync(join(moxxyHome, 'config'))) {
+      ok('Config directory exists');
+    } else {
+      warning('Config directory missing. Run: moxxy init');
+    }
+
+    const dbPath = join(moxxyHome, 'moxxy.db');
+    if (existsSync(dbPath)) {
+      const size = statSync(dbPath).size;
+      ok(`Database: ${dbPath} (${formatBytes(size)})`);
+    } else {
+      warning('Database not found. Start the gateway to create it.');
+    }
+  } else {
+    error(`Moxxy home not found: ${moxxyHome}`);
+    p.log.info('  Run: moxxy init');
+  }
+
+  // ── 2. Environment Variables ──
+
+  const apiUrl = process.env.MOXXY_API_URL || 'http://localhost:3000';
+  ok(`API URL: ${apiUrl}`);
+
+  if (process.env.MOXXY_TOKEN) {
+    const token = process.env.MOXXY_TOKEN;
+    const masked = token.slice(0, 8) + '...' + token.slice(-4);
+    ok(`API token set: ${masked}`);
+  } else {
+    warning('MOXXY_TOKEN not set. Some commands will fail.');
+    p.log.info('  Run: moxxy init  or  moxxy auth token create');
+  }
+
+  // ── 3. Gateway Connectivity ──
+
+  try {
+    const resp = await fetch(`${apiUrl}/v1/providers`);
+    if (resp) {
+      ok(`Gateway reachable at ${apiUrl} (HTTP ${resp.status})`);
+    }
+  } catch {
+    error(`Gateway not reachable at ${apiUrl}`);
+    p.log.info('  Run: moxxy gateway start  or  cargo run -p moxxy-gateway');
+  }
+
+  // ── 4. Auth Check ──
+
+  if (process.env.MOXXY_TOKEN) {
+    try {
+      await client.listTokens();
+      ok('Authentication working');
+    } catch (err) {
+      if (err.status === 401) {
+        error('Token is invalid or expired');
+        p.log.info('  Run: moxxy auth token create');
+      } else if (err.status === 403) {
+        warning('Token lacks tokens:admin scope (auth check limited)');
+      } else {
+        warning(`Auth check inconclusive: ${err.message}`);
+      }
+    }
+  }
+
+  // ── 5. Providers ──
+
+  try {
+    const providers = await client.listProviders();
+    if (Array.isArray(providers) && providers.length > 0) {
+      ok(`Providers installed: ${providers.map(pr => pr.display_name || pr.id).join(', ')}`);
+    } else {
+      warning('No providers installed. Run: moxxy provider install');
+    }
+  } catch {
+    // Skip if gateway/auth not available
+  }
+
+  // ── 6. Agents ──
+
+  try {
+    const agents = await client.listAgents();
+    if (Array.isArray(agents) && agents.length > 0) {
+      const running = agents.filter(a => a.status === 'running').length;
+      ok(`Agents: ${agents.length} total, ${running} running`);
+    } else {
+      warning('No agents created. Run: moxxy agent create');
+    }
+  } catch {
+    // Skip if gateway/auth not available
+  }
+
+  // ── 7. Rust Toolchain ──
+
+  try {
+    const rustVersion = execSync('rustc --version', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+    ok(`Rust: ${rustVersion}`);
+  } catch {
+    warning('Rust not found. Required to build/run the gateway.');
+    p.log.info('  Install: https://rustup.rs');
+  }
+
+  // ── 8. Node.js Runtime ──
+
+  try {
+    const nodeVersion = execSync('node --version', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+    const parts = nodeVersion.replace(/^v/, '').split('.').map(Number);
+    const nodeOk = parts[0] >= 18;
+    if (nodeOk) {
+      ok(`Node.js: ${nodeVersion}`);
+    } else {
+      error(`Node.js ${nodeVersion} is too old. Requires >= 18.0.0`);
+      p.log.info('  Update: https://nodejs.org');
+    }
+  } catch {
+    error('Node.js not found. Required to run the CLI.');
+    p.log.info('  Install: https://nodejs.org');
+  }
+
+  // ── 9. Git ──
+
+  try {
+    const gitVersion = execSync('git --version', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+    ok(`Git: ${gitVersion}`);
+  } catch {
+    warning('Git not found. Required for git.* primitives.');
+  }
+
+  // ── 10. Chrome/Chromium ──
+
+  const chromePaths = [
+    process.env.CHROME_PATH,
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/usr/bin/google-chrome',
+    '/usr/bin/google-chrome-stable',
+    '/usr/bin/chromium',
+    '/usr/bin/chromium-browser',
+    ...(platform() === 'win32' ? [
+      join(process.env.PROGRAMFILES || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
+      join(process.env.LOCALAPPDATA || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
+      join(process.env.PROGRAMFILES || '', 'Chromium', 'Application', 'chrome.exe'),
+    ] : []),
+  ].filter(Boolean);
+
+  let chromeFound = false;
+  for (const chromePath of chromePaths) {
+    if (existsSync(chromePath)) {
+      ok(`Chrome/Chromium: ${chromePath}`);
+      chromeFound = true;
+      break;
+    }
+  }
+  if (!chromeFound) {
+    try {
+      const cmd = platform() === 'win32'
+        ? 'where google-chrome chromium 2>nul'
+        : 'which google-chrome chromium';
+      const found = execSync(cmd, { encoding: 'utf-8', stdio: 'pipe' }).trim();
+      if (found) {
+        ok(`Chrome/Chromium: ${found.split('\n')[0]}`);
+        chromeFound = true;
+      }
+    } catch { /* ignore */ }
+  }
+  if (!chromeFound) {
+    warning('Chrome/Chromium not found. Optional for browse.* primitives with JS rendering.');
+  }
+
+  // ── 11. API Key Environment Variables ──
+
+  const apiKeys = [
+    { env: 'ANTHROPIC_API_KEY', name: 'Anthropic' },
+    { env: 'OPENAI_API_KEY', name: 'OpenAI' },
+    { env: 'XAI_API_KEY', name: 'xAI' },
+    { env: 'GOOGLE_API_KEY', name: 'Google' },
+    { env: 'DEEPSEEK_API_KEY', name: 'DeepSeek' },
+  ];
+
+  const setKeys = apiKeys.filter(k => process.env[k.env]);
+  if (setKeys.length > 0) {
+    ok(`API keys found: ${setKeys.map(k => k.name).join(', ')}`);
+  } else {
+    warning('No provider API keys set in environment');
+    p.log.info('  Set one of: ANTHROPIC_API_KEY, OPENAI_API_KEY, XAI_API_KEY, ...');
+  }
+
+  // ── 12. Plugins ──
+
+  try {
+    const { pluginPaths, readRegistry, isProcessAlive } = await import('../lib/plugin-registry.js');
+    const { registryFile } = pluginPaths();
+    if (existsSync(registryFile)) {
+      const registry = readRegistry();
+      const plugins = Object.values(registry.plugins);
+      const running = plugins.filter(pl => pl.status === 'running' && pl.pid && isProcessAlive(pl.pid));
+      ok(`Plugins: ${plugins.length} installed, ${running.length} running`);
+      for (const plug of running) {
+        ok(`  ${plug.name} v${plug.version} (PID ${plug.pid})`);
+      }
+      const zombies = plugins.filter(pl => pl.status === 'running' && pl.pid && !isProcessAlive(pl.pid));
+      for (const z of zombies) {
+        warning(`  ${z.name} marked running but PID ${z.pid} is dead`);
+      }
+    }
+  } catch { /* plugins not set up yet */ }
+
+  // ── Summary ──
+
+  const total = pass + warn + fail;
+  p.note(
+    `${pass}/${total} checks passed\n${warn} warning(s)\n${fail} error(s)`,
+    fail === 0 ? 'All good' : 'Issues found',
+  );
+
+  if (fail === 0 && warn === 0) {
+    p.outro('Moxxy is healthy!');
+  } else if (fail === 0) {
+    p.outro('Moxxy is working but has some warnings.');
+  } else {
+    p.outro('Fix the errors above to get Moxxy working.');
+    process.exitCode = 1;
+  }
+}
+
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}

package/src/commands/events.js

@@ -0,0 +1,80 @@
+/**
+ * Events command: tail SSE stream.
+ */
+import { createSseClient } from '../sse-client.js';
+import { parseFlags } from './auth.js';
+import { isInteractive, handleCancel, pickAgent, p } from '../ui.js';
+
+export async function runEvents(client, args) {
+  let [action, ...rest] = args;
+
+  // Default to 'tail' in interactive mode when no action
+  if (!action && isInteractive()) {
+    action = 'tail';
+  }
+
+  if (action !== 'tail') {
+    const { showHelp } = await import('../help.js');
+    showHelp('events', p);
+    return;
+  }
+
+  const flags = parseFlags(rest);
+  const filters = {};
+
+  // Interactive filter wizard when no filters provided
+  if (!flags.agent && !flags.run && isInteractive()) {
+    const filterMode = await p.select({
+      message: 'Event filter',
+      options: [
+        { value: 'all',   label: 'All events',  hint: 'stream all events' },
+        { value: 'agent', label: 'By agent',     hint: 'filter by specific agent' },
+      ],
+    });
+    handleCancel(filterMode);
+
+    if (filterMode === 'agent') {
+      const agentId = await pickAgent(client, 'Select agent to tail');
+      filters.agent_id = agentId;
+    }
+  } else {
+    if (flags.agent) filters.agent_id = flags.agent;
+    if (flags.run) filters.run_id = flags.run;
+  }
+
+  const sse = createSseClient(client.baseUrl, client.token, filters);
+
+  if (isInteractive()) {
+    p.log.info(`Connecting to ${sse.url} ...`);
+  } else {
+    console.error(`Connecting to ${sse.url} ...`);
+  }
+
+  process.on('SIGINT', () => {
+    sse.disconnect();
+    if (isInteractive()) {
+      p.log.info('Disconnected.');
+    } else {
+      console.error('\nDisconnected.');
+    }
+    process.exit(0);
+  });
+
+  try {
+    for await (const event of sse.stream()) {
+      if (flags.json === true || flags.json === 'true') {
+        console.log(JSON.stringify(event));
+      } else {
+        const ts = event.ts ? new Date(event.ts).toISOString() : '?';
+        const type = event.event_type || 'unknown';
+        const agent = event.agent_id || '-';
+        console.log(`[${ts}] ${type} agent=${agent} ${JSON.stringify(event.payload || {})}`);
+      }
+    }
+  } catch (err) {
+    if (err.name !== 'AbortError') {
+      console.error(`SSE error: ${err.message}`);
+      process.exitCode = 1;
+    }
+  }
+}