@moxxy/cli 0.1.0 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moxxy/cli",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "CLI for the Moxxy agentic framework — manage agents, skills, plugins, channels, and vaults from the terminal",
   "type": "module",
   "license": "MIT",

package/src/cli.js

@@ -16,6 +16,7 @@ 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 { runSettings } from './commands/settings.js';
 import { COMMAND_HELP, showHelp } from './help.js';
 import chalk from 'chalk';
 import { createInterface, cursorTo, clearScreenDown } from 'node:readline';
@@ -87,6 +88,9 @@ Usage:
   moxxy tui [--agent <id>]                            Full-screen chat interface
   moxxy chat [--agent <id>]                           Alias for tui
   moxxy events tail [--agent <id>] [--run <id>] [--json]
+  moxxy settings network-mode [safe|unsafe]           Get or set network mode
+  moxxy settings get [--key <k>] [--json]            View settings
+  moxxy settings set --key <k> --value <v>           Set a setting
   moxxy doctor                                       Diagnose installation
   moxxy update [--check] [--force] [--json]          Check for and install updates
   moxxy update --rollback                            Restore previous gateway version
@@ -168,6 +172,9 @@ async function routeCommand(client, command, rest) {
     case 'plugin':
       await runPlugin(client, rest);
       break;
+    case 'settings':
+      await runSettings(client, rest);
+      break;
     case 'tui':
     case 'chat': {
       const { startTui } = await import('./tui/index.jsx');
@@ -217,7 +224,7 @@ async function main() {
     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' },
+    system:       { label: 'System',       hint: 'settings, update & uninstall' },
   };
 
   const SUBMENUS = {
@@ -246,6 +253,7 @@ async function main() {
       { value: 'events',    label: 'Events',    hint: 'stream live events' },
     ],
     system: [
+      { value: 'settings',  label: 'Settings',  hint: 'network mode & global config' },
       { value: 'update',    label: 'Update',    hint: 'check for and install updates' },
       { value: 'uninstall', label: 'Uninstall', hint: 'remove all Moxxy data' },
     ],

package/src/commands/init.js

@@ -763,5 +763,192 @@ export async function runInit(client, args) {
     }
   }
 
+  // Step 7: Browser rendering (optional)
+  p.note(
+    'Browser rendering enables agents to load JavaScript-heavy websites\n' +
+    'using a headless Chrome browser. This requires Chrome/Chromium.\n' +
+    'Without it, agents can still fetch pages via HTTP (works for most sites).',
+    'Browser Rendering'
+  );
+
+  const enableBrowser = await p.confirm({
+    message: 'Enable browser rendering capabilities?',
+    initialValue: false,
+  });
+  handleCancel(enableBrowser);
+
+  if (enableBrowser) {
+    const chromePath = detectChromeBinary(moxxyHome);
+
+    if (chromePath) {
+      p.log.success(`Chrome found: ${chromePath}`);
+      saveBrowserRenderingSetting(moxxyHome, true);
+      p.log.success('Browser rendering enabled.');
+    } else {
+      p.log.warn('Chrome/Chromium not found on this system.');
+
+      const downloadChrome = await p.confirm({
+        message: 'Download Chromium (~150MB) to ~/.moxxy/chromium/?',
+        initialValue: true,
+      });
+      handleCancel(downloadChrome);
+
+      if (downloadChrome) {
+        const installed = await installChromium(moxxyHome);
+        if (installed) {
+          saveBrowserRenderingSetting(moxxyHome, true);
+          p.log.success('Browser rendering enabled.');
+        } else {
+          p.log.warn('Chromium install failed. You can retry later with: moxxy settings browser-rendering');
+        }
+      } else {
+        p.log.info('Skipped. Install Chrome manually or run: moxxy settings browser-rendering');
+      }
+    }
+  }
+
   p.outro('Setup complete. Run moxxy to see available commands.');
 }
+
+// ---------------------------------------------------------------------------
+// Browser rendering helpers
+// ---------------------------------------------------------------------------
+
+function detectChromeBinary(moxxyHome) {
+  const os = platform();
+
+  // 1. CHROME_PATH env var
+  if (process.env.CHROME_PATH && existsSync(process.env.CHROME_PATH)) {
+    return process.env.CHROME_PATH;
+  }
+
+  // 2. System Chrome
+  const systemPaths = os === 'darwin'
+    ? [
+        '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+        '/Applications/Chromium.app/Contents/MacOS/Chromium',
+      ]
+    : [
+        '/usr/bin/google-chrome',
+        '/usr/bin/google-chrome-stable',
+        '/usr/bin/chromium',
+        '/usr/bin/chromium-browser',
+      ];
+
+  for (const p of systemPaths) {
+    if (existsSync(p)) return p;
+  }
+
+  // 3. which fallback (Linux)
+  if (os === 'linux') {
+    for (const name of ['google-chrome', 'chromium-browser', 'chromium']) {
+      try {
+        const result = execSync(`which ${name}`, { stdio: 'pipe', encoding: 'utf-8' }).trim();
+        if (result && existsSync(result)) return result;
+      } catch { /* not found */ }
+    }
+  }
+
+  // 4. Previously downloaded
+  const platDir = chromePlatformDir();
+  const binaryName = os === 'darwin'
+    ? 'Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing'
+    : 'chrome';
+  const downloaded = join(moxxyHome, 'chromium', platDir, binaryName);
+  if (existsSync(downloaded)) return downloaded;
+
+  return null;
+}
+
+function chromePlatformDir() {
+  const os = platform();
+  const cpuArch = arch();
+  if (os === 'darwin') {
+    return cpuArch === 'arm64' ? 'chrome-mac-arm64' : 'chrome-mac-x64';
+  }
+  return 'chrome-linux64';
+}
+
+async function installChromium(moxxyHome) {
+  const CHROME_FOR_TESTING_API = 'https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions-with-downloads.json';
+
+  try {
+    // Fetch latest stable version info
+    const versionInfo = await withSpinner('Fetching Chromium version info...', async () => {
+      const resp = await fetch(CHROME_FOR_TESTING_API, { signal: AbortSignal.timeout(15000) });
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+      return resp.json();
+    }, 'Version info retrieved.');
+
+    const platKey = chromePlatformKey();
+    const stable = versionInfo.channels.Stable;
+    const chromeDownloads = stable.downloads.chrome;
+    const entry = chromeDownloads.find(d => d.platform === platKey);
+
+    if (!entry) {
+      p.log.error(`No Chromium build for platform: ${platKey}`);
+      return false;
+    }
+
+    const downloadUrl = entry.url;
+    const targetDir = join(moxxyHome, 'chromium');
+    mkdirSync(targetDir, { recursive: true });
+
+    const zipPath = join(targetDir, 'chrome.zip');
+
+    // Download
+    await withSpinner(`Downloading Chromium ${stable.version}...`, async () => {
+      const resp = await fetch(downloadUrl, { signal: AbortSignal.timeout(300000) });
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+      const fileStream = createWriteStream(zipPath);
+      await pipeline(resp.body, fileStream);
+    }, 'Download complete.');
+
+    // Extract
+    await withSpinner('Extracting Chromium...', async () => {
+      execSync(`unzip -o -q "${zipPath}" -d "${targetDir}"`, { stdio: 'pipe' });
+    }, 'Extraction complete.');
+
+    // Cleanup zip
+    try { const { unlinkSync } = await import('node:fs'); unlinkSync(zipPath); } catch { /* ignore */ }
+
+    const chromePath = detectChromeBinary(moxxyHome);
+    if (chromePath) {
+      // Make executable on Linux
+      if (platform() === 'linux') {
+        try { chmodSync(chromePath, 0o755); } catch { /* ignore */ }
+      }
+      p.log.success(`Chromium installed: ${chromePath}`);
+      return true;
+    }
+
+    p.log.error('Extraction succeeded but Chrome binary not found');
+    return false;
+  } catch (err) {
+    p.log.error(`Failed to install Chromium: ${err.message}`);
+    return false;
+  }
+}
+
+function chromePlatformKey() {
+  const os = platform();
+  const cpuArch = arch();
+  if (os === 'darwin') {
+    return cpuArch === 'arm64' ? 'mac-arm64' : 'mac-x64';
+  }
+  return 'linux64';
+}
+
+function saveBrowserRenderingSetting(moxxyHome, enabled) {
+  const settingsFile = join(moxxyHome, 'settings.yaml');
+  let lines = [];
+  try {
+    const raw = readFileSync(settingsFile, 'utf-8');
+    lines = raw.split('\n').filter(l => !l.startsWith('browser_rendering:'));
+  } catch { /* no existing settings */ }
+
+  lines.push(`browser_rendering: ${enabled}`);
+
+  mkdirSync(moxxyHome, { recursive: true });
+  writeFileSync(settingsFile, lines.filter(l => l.trim()).join('\n') + '\n');
+}

package/src/commands/settings.js

@@ -0,0 +1,224 @@
+import { p, isInteractive, showResult } from '../ui.js';
+import { parseFlags } from './auth.js';
+import { getMoxxyHome } from './init.js';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const VALID_NETWORK_MODES = ['safe', 'unsafe'];
+
+function settingsPath() {
+  return join(getMoxxyHome(), 'settings.yaml');
+}
+
+function loadSettings() {
+  try {
+    const raw = readFileSync(settingsPath(), 'utf-8');
+    if (!raw.trim()) return {};
+    const settings = {};
+    for (const line of raw.split('\n')) {
+      const match = line.match(/^(\w+):\s*(.+)$/);
+      if (match) settings[match[1]] = match[2].trim();
+    }
+    return settings;
+  } catch {
+    return {};
+  }
+}
+
+function saveSettings(settings) {
+  const dir = getMoxxyHome();
+  mkdirSync(dir, { recursive: true });
+  const lines = Object.entries(settings).map(([k, v]) => `${k}: ${v}`);
+  writeFileSync(settingsPath(), lines.join('\n') + '\n');
+}
+
+export function parseSettingsCommand(args) {
+  const [action, ...rest] = args;
+  const flags = parseFlags(rest);
+  return { action, flags };
+}
+
+async function settingsGet(flags) {
+  const settings = loadSettings();
+  const key = flags.key;
+
+  if (flags.json) {
+    console.log(JSON.stringify(key ? { key, value: settings[key] ?? null } : settings, null, 2));
+    return;
+  }
+
+  if (key) {
+    const value = settings[key] ?? '(not set)';
+    p.log.info(`${key}: ${value}`);
+  } else {
+    const entries = Object.entries(settings);
+    if (entries.length === 0) {
+      p.log.info('No settings configured. Using defaults.');
+      p.log.info('  network_mode: safe (default)');
+    } else {
+      for (const [k, v] of entries) {
+        p.log.info(`${k}: ${v}`);
+      }
+    }
+  }
+}
+
+async function settingsSet(flags) {
+  const key = flags.key;
+  const value = flags.value;
+
+  if (!key) throw new Error('Required: --key');
+  if (value === undefined) throw new Error('Required: --value');
+
+  // Validate known keys
+  if (key === 'network_mode' && !VALID_NETWORK_MODES.includes(value)) {
+    throw new Error(`Invalid network_mode '${value}'. Must be one of: ${VALID_NETWORK_MODES.join(', ')}`);
+  }
+
+  const settings = loadSettings();
+  settings[key] = value;
+  saveSettings(settings);
+
+  if (flags.json) {
+    console.log(JSON.stringify({ status: 'updated', key, value }, null, 2));
+  } else {
+    showResult({ status: 'updated', key, value }, p);
+  }
+}
+
+async function settingsNetworkMode(flags) {
+  const settings = loadSettings();
+  const current = settings.network_mode || 'safe';
+
+  // No value provided — show current or toggle interactively
+  if (!flags.mode && !flags._positional) {
+    if (isInteractive()) {
+      const selected = await p.select({
+        message: `Network mode (currently: ${current})`,
+        options: [
+          { value: 'safe', label: 'Safe', hint: 'agent asks user before accessing non-allowlisted domains' },
+          { value: 'unsafe', label: 'Unsafe', hint: 'domain allowlist is bypassed entirely' },
+        ],
+        initialValue: current,
+      });
+      if (p.isCancel(selected)) return;
+      settings.network_mode = selected;
+      saveSettings(settings);
+      p.log.success(`Network mode set to: ${selected}`);
+    } else {
+      if (flags.json) {
+        console.log(JSON.stringify({ network_mode: current }, null, 2));
+      } else {
+        p.log.info(`network_mode: ${current}`);
+      }
+    }
+    return;
+  }
+
+  const mode = flags.mode || flags._positional;
+  if (!VALID_NETWORK_MODES.includes(mode)) {
+    throw new Error(`Invalid mode '${mode}'. Must be one of: ${VALID_NETWORK_MODES.join(', ')}`);
+  }
+
+  settings.network_mode = mode;
+  saveSettings(settings);
+
+  if (flags.json) {
+    console.log(JSON.stringify({ status: 'updated', network_mode: mode }, null, 2));
+  } else {
+    p.log.success(`Network mode set to: ${mode}`);
+  }
+}
+
+async function settingsBrowserRendering(flags) {
+  const settings = loadSettings();
+  const current = settings.browser_rendering === 'true';
+
+  // No value provided — show current or toggle interactively
+  if (!flags._positional) {
+    if (isInteractive()) {
+      const selected = await p.select({
+        message: `Browser rendering (currently: ${current ? 'enabled' : 'disabled'})`,
+        options: [
+          { value: 'true', label: 'Enabled', hint: 'agents can render JS-heavy pages via headless Chrome' },
+          { value: 'false', label: 'Disabled', hint: 'agents use HTTP-only browsing' },
+        ],
+        initialValue: current ? 'true' : 'false',
+      });
+      if (p.isCancel(selected)) return;
+      settings.browser_rendering = selected;
+      saveSettings(settings);
+      p.log.success(`Browser rendering ${selected === 'true' ? 'enabled' : 'disabled'}.`);
+    } else {
+      if (flags.json) {
+        console.log(JSON.stringify({ browser_rendering: current }, null, 2));
+      } else {
+        p.log.info(`browser_rendering: ${current}`);
+      }
+    }
+    return;
+  }
+
+  const val = flags._positional;
+  if (!['true', 'false', 'on', 'off', 'enable', 'disable'].includes(val)) {
+    throw new Error(`Invalid value '${val}'. Use: true/false, on/off, or enable/disable`);
+  }
+
+  const enabled = ['true', 'on', 'enable'].includes(val);
+  settings.browser_rendering = String(enabled);
+  saveSettings(settings);
+
+  if (flags.json) {
+    console.log(JSON.stringify({ status: 'updated', browser_rendering: enabled }, null, 2));
+  } else {
+    p.log.success(`Browser rendering ${enabled ? 'enabled' : 'disabled'}.`);
+  }
+}
+
+export async function runSettings(_client, args) {
+  const { action, flags } = parseSettingsCommand(args);
+
+  // Collect first positional arg after the action for convenience
+  // e.g. `moxxy settings network-mode unsafe`
+  const restArgs = args.slice(1).filter(a => !a.startsWith('--'));
+  if (restArgs.length > 0 && !flags._positional) {
+    flags._positional = restArgs[0];
+  }
+
+  switch (action) {
+    case 'get':
+      await settingsGet(flags);
+      break;
+    case 'set':
+      await settingsSet(flags);
+      break;
+    case 'network-mode':
+      await settingsNetworkMode(flags);
+      break;
+    case 'browser-rendering':
+      await settingsBrowserRendering(flags);
+      break;
+    default:
+      if (isInteractive() && !action) {
+        // Interactive: show settings menu
+        const selected = await p.select({
+          message: 'Settings',
+          options: [
+            { value: 'network-mode', label: 'Network mode', hint: 'safe / unsafe domain access' },
+            { value: 'browser-rendering', label: 'Browser rendering', hint: 'headless Chrome for JS-heavy sites' },
+            { value: 'get', label: 'View all settings', hint: 'show current configuration' },
+          ],
+        });
+        if (p.isCancel(selected)) return;
+        await runSettings(_client, [selected]);
+      } else {
+        throw new Error(
+          'Usage: moxxy settings <action>\n' +
+          '  network-mode [safe|unsafe]         Get or set network mode\n' +
+          '  browser-rendering [true|false]     Enable/disable headless Chrome rendering\n' +
+          '  get [--key <k>]                    View settings\n' +
+          '  set --key <k> --value <v>          Set a setting'
+        );
+      }
+  }
+}

package/src/help.js

@@ -1,4 +1,28 @@
 export const COMMAND_HELP = {
+  settings: `Usage: moxxy settings <action> [options]
+
+Manage global Moxxy settings.
+
+Actions:
+  network-mode [safe|unsafe]   Get or set network mode
+  get [--key <k>]              View all settings or a single key
+  set --key <k> --value <v>    Set a setting value
+
+Network Modes:
+  safe      (default) Agent asks the user before accessing non-allowlisted domains
+  unsafe    Domain allowlist is bypassed entirely — any domain is allowed
+
+Options:
+  --json    Output as JSON
+
+Examples:
+  moxxy settings network-mode              Show current mode
+  moxxy settings network-mode unsafe       Switch to unsafe mode
+  moxxy settings network-mode safe         Switch back to safe mode
+  moxxy settings get                       Show all settings
+  moxxy settings get --key network_mode    Show a single setting
+  moxxy settings set --key network_mode --value unsafe`,
+
   init: `Usage: moxxy init
 
 First-time setup wizard. Configures the Moxxy home directory, auth mode,