@moxxy/cli 0.0.12 → 0.1.0

package/src/commands/gateway.js

@@ -0,0 +1,428 @@
+import { p, handleCancel, withSpinner } from '../ui.js';
+import { getMoxxyHome } from './init.js';
+import { execSync, spawn } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir, platform } from 'node:os';
+
+const PLIST_LABEL = 'ai.moxxy.gateway';
+const SYSTEMD_UNIT = 'moxxy-gateway.service';
+
+function normalizeApiUrl(apiUrl) {
+  const raw = (apiUrl || '').trim();
+  if (!raw) return 'http://localhost:3000';
+  const withoutTrailingSlash = raw.replace(/\/+$/, '');
+  const withoutV1Suffix = withoutTrailingSlash.replace(/\/v1$/i, '');
+  return withoutV1Suffix || withoutTrailingSlash;
+}
+
+function paths() {
+  const home = getMoxxyHome();
+  const binName = platform() === 'win32' ? 'moxxy-gateway.exe' : 'moxxy-gateway';
+  const bin = join(home, 'bin', binName);
+  const logDir = join(home, 'logs');
+  const logFile = join(logDir, 'gateway.log');
+  const pidFile = join(home, 'gateway.pid');
+  return { home, bin, logDir, logFile, pidFile };
+}
+
+function findBinary() {
+  const { bin } = paths();
+  if (existsSync(bin)) return bin;
+
+  // Check PATH
+  const cmd = platform() === 'win32' ? 'where moxxy-gateway' : 'which moxxy-gateway';
+  try {
+    const found = execSync(cmd, { encoding: 'utf-8', stdio: 'pipe' }).trim();
+    if (found) return found.split('\n')[0]; // `where` on Windows may return multiple lines
+  } catch { /* not on PATH */ }
+
+  return null;
+}
+
+// --- Platform-specific service management ---
+
+function plistPath() {
+  return join(homedir(), 'Library', 'LaunchAgents', `${PLIST_LABEL}.plist`);
+}
+
+function systemdUnitPath() {
+  return join(homedir(), '.config', 'systemd', 'user', SYSTEMD_UNIT);
+}
+
+function generatePlist(binaryPath) {
+  const { logFile, logDir } = paths();
+  mkdirSync(logDir, { recursive: true });
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${binaryPath}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <false/>
+  <key>KeepAlive</key>
+  <false/>
+  <key>StandardOutPath</key>
+  <string>${logFile}</string>
+  <key>StandardErrorPath</key>
+  <string>${logFile}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>MOXXY_HOME</key>
+    <string>${getMoxxyHome()}</string>
+  </dict>
+</dict>
+</plist>`;
+}
+
+function generateSystemdUnit(binaryPath) {
+  const { logFile, logDir } = paths();
+  mkdirSync(logDir, { recursive: true });
+
+  return `[Unit]
+Description=Moxxy Gateway
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${binaryPath}
+Environment=MOXXY_HOME=${getMoxxyHome()}
+StandardOutput=append:${logFile}
+StandardError=append:${logFile}
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target`;
+}
+
+// --- Actions ---
+
+async function startGateway() {
+  const binary = findBinary();
+  if (!binary) {
+    p.log.error('moxxy-gateway binary not found.');
+    p.log.info('Install it with: moxxy init');
+    process.exitCode = 1;
+    return;
+  }
+
+  const os = platform();
+
+  if (os === 'darwin') {
+    await startLaunchd(binary);
+  } else if (os === 'linux') {
+    await startSystemd(binary);
+  } else {
+    await startFallback(binary);
+  }
+}
+
+async function startLaunchd(binary) {
+  const plist = plistPath();
+  const dir = join(homedir(), 'Library', 'LaunchAgents');
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(plist, generatePlist(binary));
+
+  try {
+    // Bootout first in case it's already loaded
+    execSync(`launchctl bootout gui/$(id -u) ${plist} 2>/dev/null`, { stdio: 'ignore' });
+  } catch { /* not loaded, fine */ }
+
+  execSync(`launchctl bootstrap gui/$(id -u) ${plist}`);
+  execSync(`launchctl kickstart -k gui/$(id -u)/${PLIST_LABEL}`);
+
+  await verifyStarted();
+}
+
+async function startSystemd(binary) {
+  const unitPath = systemdUnitPath();
+  const dir = join(homedir(), '.config', 'systemd', 'user');
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(unitPath, generateSystemdUnit(binary));
+
+  execSync('systemctl --user daemon-reload');
+  execSync(`systemctl --user start ${SYSTEMD_UNIT}`);
+
+  await verifyStarted();
+}
+
+async function startFallback(binary) {
+  const { logDir, logFile, pidFile } = paths();
+  mkdirSync(logDir, { recursive: true });
+
+  const { openSync } = await import('node:fs');
+  const logFd = openSync(logFile, 'a');
+
+  const env = { ...process.env, MOXXY_HOME: getMoxxyHome() };
+  const child = spawn(binary, [], {
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    env,
+  });
+
+  writeFileSync(pidFile, String(child.pid));
+  child.unref();
+
+  await verifyStarted();
+}
+
+async function stopGateway() {
+  const os = platform();
+
+  if (os === 'darwin') {
+    await stopLaunchd();
+  } else if (os === 'linux') {
+    await stopSystemd();
+  } else {
+    await stopFallback();
+  }
+}
+
+async function stopLaunchd() {
+  const plist = plistPath();
+
+  try {
+    execSync(`launchctl bootout gui/$(id -u) ${plist}`);
+    p.log.success('Gateway stopped.');
+  } catch {
+    p.log.warn('Gateway service not running or not loaded.');
+  }
+}
+
+async function stopSystemd() {
+  try {
+    execSync(`systemctl --user stop ${SYSTEMD_UNIT}`);
+    p.log.success('Gateway stopped.');
+  } catch {
+    p.log.warn('Gateway service not running.');
+  }
+}
+
+async function stopFallback() {
+  const { pidFile } = paths();
+
+  if (!existsSync(pidFile)) {
+    p.log.warn('No PID file found. Gateway may not be running.');
+    return;
+  }
+
+  const pid = parseInt(readFileSync(pidFile, 'utf-8').trim(), 10);
+
+  try {
+    process.kill(pid, 'SIGTERM');
+    p.log.success(`Gateway stopped (PID ${pid}).`);
+  } catch (err) {
+    if (err.code === 'ESRCH') {
+      p.log.warn(`Process ${pid} not found. Cleaning up stale PID file.`);
+    } else {
+      throw err;
+    }
+  }
+
+  try { unlinkSync(pidFile); } catch { /* already gone */ }
+}
+
+async function restartGateway() {
+  p.log.step('Stopping gateway...');
+  await stopGateway();
+
+  // Brief pause to let the port release
+  await new Promise(r => setTimeout(r, 1000));
+
+  p.log.step('Starting gateway...');
+  await startGateway();
+}
+
+async function probeGatewayHealth(apiUrl, timeoutMs = 2000) {
+  const normalizedApiUrl = normalizeApiUrl(apiUrl);
+  try {
+    const resp = await fetch(`${normalizedApiUrl}/v1/health`, { signal: AbortSignal.timeout(timeoutMs) });
+    const text = await resp.text().catch(() => '');
+    let payload = null;
+    try {
+      payload = text ? JSON.parse(text) : null;
+    } catch { /* ignore non-json health body */ }
+
+    const isHealthy = resp.ok && payload?.status === 'healthy';
+    if (isHealthy) {
+      return { ok: true, status: resp.status, reason: '' };
+    }
+
+    const reason = payload?.message
+      || payload?.status
+      || (resp.status === 404 ? 'endpoint /v1/health not found' : `HTTP ${resp.status}`);
+    return { ok: false, status: resp.status, reason };
+  } catch (err) {
+    return { ok: false, status: 0, reason: err?.message || 'not reachable' };
+  }
+}
+
+async function gatewayStatus() {
+  const os = platform();
+  let serviceRunning = false;
+  let pid = null;
+
+  if (os === 'darwin') {
+    try {
+      const out = execSync(`launchctl print gui/$(id -u)/${PLIST_LABEL} 2>/dev/null`, { encoding: 'utf-8' });
+      const pidMatch = out.match(/pid\s*=\s*(\d+)/);
+      if (pidMatch) {
+        pid = pidMatch[1];
+        serviceRunning = true;
+      }
+    } catch { /* not loaded */ }
+  } else if (os === 'linux') {
+    try {
+      execSync(`systemctl --user is-active ${SYSTEMD_UNIT}`, { stdio: 'ignore' });
+      serviceRunning = true;
+      const out = execSync(`systemctl --user show ${SYSTEMD_UNIT} --property=MainPID`, { encoding: 'utf-8' });
+      const pidMatch = out.match(/MainPID=(\d+)/);
+      if (pidMatch && pidMatch[1] !== '0') pid = pidMatch[1];
+    } catch { /* not active */ }
+  }
+
+  // Fallback: check PID file
+  if (!serviceRunning) {
+    const { pidFile } = paths();
+    if (existsSync(pidFile)) {
+      pid = readFileSync(pidFile, 'utf-8').trim();
+      try {
+        process.kill(parseInt(pid, 10), 0);
+        serviceRunning = true;
+      } catch {
+        serviceRunning = false;
+        pid = null;
+      }
+    }
+  }
+
+  const apiUrl = normalizeApiUrl(process.env.MOXXY_API_URL || 'http://localhost:3000');
+  const health = await probeGatewayHealth(apiUrl);
+
+  if (serviceRunning) {
+    p.log.success(`Gateway is running${pid ? ` (PID ${pid})` : ''}`);
+  } else {
+    p.log.warn('Gateway is not running.');
+  }
+
+  if (health.ok) {
+    p.log.success(`Health check: reachable at ${apiUrl}`);
+  } else {
+    p.log.warn(`Health check: not healthy at ${apiUrl}${health.reason ? ` (${health.reason})` : ''}`);
+  }
+
+  const binary = findBinary();
+  if (binary) {
+    p.log.info(`Binary: ${binary}`);
+  } else {
+    p.log.warn('Binary: not found');
+  }
+}
+
+async function gatewayLogs() {
+  const { logFile } = paths();
+
+  if (!existsSync(logFile)) {
+    p.log.warn(`No log file found at ${logFile}`);
+    return;
+  }
+
+  p.log.info(`Tailing ${logFile} (Ctrl+C to stop)`);
+
+  let tail;
+  if (platform() === 'win32') {
+    tail = spawn('powershell', ['-Command', `Get-Content -Path "${logFile}" -Wait -Tail 50`], { stdio: 'inherit' });
+  } else {
+    tail = spawn('tail', ['-f', logFile], { stdio: 'inherit' });
+  }
+
+  await new Promise((resolve) => {
+    process.on('SIGINT', () => {
+      tail.kill();
+      resolve();
+    });
+    tail.on('close', resolve);
+  });
+}
+
+// --- Verify health after start ---
+
+async function verifyStarted() {
+  const apiUrl = normalizeApiUrl(process.env.MOXXY_API_URL || 'http://localhost:3000');
+  let ok = false;
+  let lastReason = '';
+
+  for (let i = 0; i < 10; i++) {
+    await new Promise(r => setTimeout(r, 500));
+    const health = await probeGatewayHealth(apiUrl, 1000);
+    if (health.ok) {
+      ok = true;
+      break;
+    }
+    lastReason = health.reason || '';
+  }
+
+  if (ok) {
+    p.log.success(`Gateway started and listening at ${apiUrl}`);
+  } else {
+    p.log.warn('Gateway process started but health check failed.');
+    if (lastReason) {
+      p.log.warn(`Last health probe error: ${lastReason}`);
+    }
+    p.log.info('Check logs with: moxxy gateway logs');
+  }
+}
+
+// --- Command router ---
+
+export { startGateway, stopGateway, findBinary, paths };
+
+export async function runGateway(client, args) {
+  const sub = args[0];
+
+  switch (sub) {
+    case 'start':
+      await startGateway();
+      break;
+    case 'stop':
+      await stopGateway();
+      break;
+    case 'restart':
+      await restartGateway();
+      break;
+    case 'status':
+      await gatewayStatus();
+      break;
+    case 'logs':
+      await gatewayLogs();
+      break;
+    default:
+      if (!sub && (await import('../ui.js')).isInteractive()) {
+        const action = await p.select({
+          message: 'Gateway action',
+          options: [
+            { value: 'start',   label: 'Start',   hint: 'start the gateway' },
+            { value: 'stop',    label: 'Stop',     hint: 'stop the gateway' },
+            { value: 'restart', label: 'Restart',  hint: 'restart the gateway' },
+            { value: 'status',  label: 'Status',   hint: 'show gateway status' },
+            { value: 'logs',    label: 'Logs',     hint: 'tail gateway logs' },
+          ],
+        });
+        handleCancel(action);
+        await runGateway(client, [action]);
+      } else {
+        const { showHelp } = await import('../help.js');
+        if (sub) {
+          p.log.error(`Unknown gateway action: ${sub}`);
+        }
+        showHelp('gateway', p);
+      }
+  }
+}

package/src/commands/heartbeat.js

@@ -0,0 +1,145 @@
+/**
+ * Heartbeat commands: set/list/disable.
+ */
+import { parseFlags } from './auth.js';
+import { isInteractive, handleCancel, withSpinner, showResult, pickAgent, p } from '../ui.js';
+
+export async function runHeartbeat(client, args) {
+  let [action, ...rest] = args;
+  const flags = parseFlags(rest);
+
+  // Interactive sub-menu when no valid action
+  if (!['set', 'list', 'disable'].includes(action) && isInteractive()) {
+    action = await p.select({
+      message: 'Heartbeat action',
+      options: [
+        { value: 'set',     label: 'Set heartbeat',     hint: 'configure heartbeat rule' },
+        { value: 'list',    label: 'List heartbeats',   hint: 'show heartbeat rules' },
+        { value: 'disable', label: 'Disable heartbeat', hint: 'turn off heartbeat' },
+      ],
+    });
+    handleCancel(action);
+  }
+
+  switch (action) {
+    case 'set': {
+      let agentId = flags.agent;
+
+      // Interactive wizard when missing agent
+      if (!agentId && isInteractive()) {
+        agentId = await pickAgent(client, 'Select agent for heartbeat');
+
+        const intervalInput = handleCancel(await p.text({
+          message: 'Interval in minutes',
+          placeholder: '5',
+          initialValue: flags.interval || '5',
+          validate: (val) => { if (!val || isNaN(parseInt(val, 10))) return 'Must be a number'; },
+        }));
+        const interval = parseInt(intervalInput, 10);
+
+        const actionType = handleCancel(await p.select({
+          message: 'Action type',
+          options: [
+            { value: 'notify_cli', label: 'Notify CLI', hint: 'send notification to CLI' },
+            { value: 'webhook',    label: 'Webhook',    hint: 'call external webhook' },
+            { value: 'restart',    label: 'Restart',    hint: 'restart the agent' },
+          ],
+        }));
+
+        const body = {
+          interval_minutes: interval,
+          action_type: actionType,
+        };
+
+        if (actionType === 'webhook') {
+          const payload = handleCancel(await p.text({
+            message: 'Webhook URL or payload',
+            placeholder: 'https://...',
+          }));
+          if (payload) body.action_payload = payload;
+        }
+
+        const result = await withSpinner('Setting heartbeat...', () =>
+          client.request(`/v1/agents/${encodeURIComponent(agentId)}/heartbeats`, 'POST', body), 'Heartbeat configured.');
+
+        showResult('Heartbeat Set', {
+          Agent: agentId,
+          Interval: `${interval} min`,
+          Action: actionType,
+        });
+
+        return result;
+      }
+
+      if (!agentId) throw new Error('Required: --agent');
+      const body = {
+        interval_minutes: parseInt(flags.interval || '5', 10),
+        action_type: flags.action_type || 'notify_cli',
+      };
+      if (flags.payload) body.action_payload = flags.payload;
+      const result = await client.request(`/v1/agents/${encodeURIComponent(agentId)}/heartbeats`, 'POST', body);
+      console.log(JSON.stringify(result, null, 2));
+      return result;
+    }
+
+    case 'list': {
+      const agentId = flags.agent;
+      if (!agentId && isInteractive()) {
+        const id = await pickAgent(client, 'Select agent to list heartbeats');
+        const result = await withSpinner('Fetching heartbeats...', () =>
+          client.request(`/v1/agents/${encodeURIComponent(id)}/heartbeats`, 'GET'), 'Heartbeats loaded.');
+        console.log(JSON.stringify(result, null, 2));
+        return result;
+      }
+      if (!agentId) throw new Error('Required: --agent');
+      const result = await client.request(`/v1/agents/${encodeURIComponent(agentId)}/heartbeats`, 'GET');
+      console.log(JSON.stringify(result, null, 2));
+      return result;
+    }
+
+    case 'disable': {
+      let agentId = flags.agent;
+      let heartbeatId = flags.id;
+
+      if ((!agentId || !heartbeatId) && isInteractive()) {
+        if (!agentId) agentId = await pickAgent(client, 'Select agent');
+
+        if (!heartbeatId) {
+          const heartbeats = await withSpinner('Fetching heartbeats...', () =>
+            client.request(`/v1/agents/${encodeURIComponent(agentId)}/heartbeats`, 'GET'), 'Loaded.');
+
+          if (!heartbeats || heartbeats.length === 0) {
+            p.log.warn('No heartbeats found for this agent.');
+            return;
+          }
+
+          heartbeatId = handleCancel(await p.select({
+            message: 'Select heartbeat to disable',
+            options: heartbeats.map(h => ({
+              value: h.id,
+              label: `${h.action_type} every ${h.interval_minutes}m`,
+              hint: h.id.slice(0, 12),
+            })),
+          }));
+        }
+      }
+
+      if (!agentId || !heartbeatId) throw new Error('Required: --agent, --id');
+
+      if (isInteractive()) {
+        await withSpinner('Disabling heartbeat...', () =>
+          client.disableHeartbeat(agentId, heartbeatId), 'Heartbeat disabled.');
+      } else {
+        await client.disableHeartbeat(agentId, heartbeatId);
+        console.log(`Heartbeat ${heartbeatId} disabled.`);
+      }
+      break;
+    }
+
+    default: {
+      const { showHelp } = await import('../help.js');
+      showHelp('heartbeat', p);
+      break;
+    }
+  }
+}