osai-agent 4.0.0

package/src/commands/register.js

@@ -0,0 +1,74 @@
+import chalk from 'chalk';
+import Conf from 'conf';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { ExitPromptError } from '@inquirer/core';
+import { printAuthHeader, printError, clearScreen } from '../ui/terminal.js';
+import { DEFAULT_SERVER_URL, toHttpUrl, toWsUrl } from '../services/server-url.js';
+import { run } from './run.js';
+import pkg from 'node-machine-id';
+const { machineIdSync } = pkg;
+
+const attemptRegister = async (email, password, serverInput, config) => {
+  const server = toWsUrl(serverInput);
+  const machineId = machineIdSync();
+  const spinner = ora('Creating account...').start();
+
+  try {
+    const response = await fetch(`${toHttpUrl(server)}/auth/register`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, password, machineId })
+    });
+    const data = await response.json();
+    if (!response.ok) { spinner.fail('Creation refused'); printError(data.error || 'Error during registration'); return 'auth_error'; }
+    config.set({ token: data.token, userId: data.user.id, plan: data.user.plan, server });
+    spinner.succeed('Account created');
+    return 'success';
+  } catch {
+    spinner.fail('Unable to create account');
+    return 'network_error';
+  }
+};
+
+export const register = async ({ server: serverOverride } = {}) => {
+  const config = new Conf({ projectName: 'osai-agent' });
+  const token = config.get('token');
+  if (token) {
+    console.log(chalk.yellow('Already logged in. Use osai-agent logout first.'));
+    return;
+  }
+  const prefixTheme = { idle: chalk.hex('#7aa2f7')('▸'), done: chalk.hex('#7aa2f7')('▸') };
+  clearScreen();
+  console.log();
+  printAuthHeader(chalk.white('Create Your Account'), 'Join OS AI Agent and get started with AI-powered automation.');
+  console.log();
+
+  let serverInput = serverOverride || config.get('server') || DEFAULT_SERVER_URL;
+
+  let email, password;
+  try {
+    ({ email, password } = await inquirer.prompt([
+      { type: 'input', name: 'email', message: 'Email \u203A', theme: { prefix: prefixTheme }, validate: (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) || 'Invalid email' },
+      { type: 'password', name: 'password', message: 'Password \u203A', theme: { prefix: prefixTheme }, mask: '*', validate: (value) => value.length >= 8 || 'Minimum 8 characters' },
+    ]));
+  } catch (err) {
+    if (err instanceof ExitPromptError) process.exit(0);
+    throw err;
+  }
+
+  const result = await attemptRegister(email, password, serverInput, config);
+  if (result === 'success') { await run({}); return; }
+  if (result !== 'network_error') return;
+
+  try {
+    const { serverInput: retryServer } = await inquirer.prompt([
+      { type: 'input', name: 'serverInput', message: 'Server \u203A', theme: { prefix: prefixTheme }, default: serverInput }
+    ]);
+    const result2 = await attemptRegister(email, password, retryServer, config);
+    if (result2 === 'success') await run({});
+  } catch (err) {
+    if (err instanceof ExitPromptError) process.exit(0);
+    throw err;
+  }
+};

package/src/commands/run.js

@@ -0,0 +1,150 @@
+import { execSync } from 'child_process';
+import Conf from 'conf';
+import chalk from 'chalk';
+import { render } from 'ink';
+import { App } from '../ui/App.js';
+import { h } from '../ui/h.js';
+import { AgentLoop } from '../agent/react-loop.js';
+import { SessionManager } from '../services/session.js';
+import { detectDefaultOS } from './config.js';
+import { toHttpUrl } from '../services/server-url.js';
+import { MODES } from '../utils/constants.js';
+import { printNotLoggedIn } from '../ui/terminal.js';
+import { disableMouseReporting } from '../ui/mouse-scroll.js';
+import { logger } from '../utils/logger.js';
+
+export const run = async ({ server: serverOverride, noConfirm = false, osOverride, coding = false, fromSession = null, local = false } = {}) => {
+  const config = new Conf({ projectName: 'osai-agent' });
+  const token = config.get('token');
+  const server = toHttpUrl(serverOverride ? `ws://${serverOverride}` : config.get('server'));
+
+  const effectiveLocal = local || (fromSession?.local ?? false);
+
+  if (!effectiveLocal) {
+    if (!token) {
+      printNotLoggedIn();
+      process.exit(1);
+    }
+    if (!server) {
+      console.error('Server URL not configured. Run: osai-agent login');
+      process.exit(1);
+    }
+  }
+
+  const resumedMode = Object.values(MODES).includes(fromSession?.mode) ? fromSession.mode : null;
+  const resumedOS = fromSession?.os;
+  const userOS = osOverride || resumedOS || config.get('os') || detectDefaultOS();
+  const startMode = coding ? MODES.CODING : (resumedMode || config.get('mode') || MODES.GENERAL);
+
+  const agentConfig = {
+    mode: startMode,
+    executionMode: config.get('executionMode') === 'PLAN' ? 'PLAN' : 'EXEC',
+    local: effectiveLocal,
+    server,
+    token,
+    noConfirm,
+    device: userOS,
+  };
+
+  let agentLoopRef = null;
+
+  const createAgentLoop = (options) => {
+    agentLoopRef = new AgentLoop(options);
+    return agentLoopRef;
+  };
+
+  // Désactiver XON/XOFF immédiatement (empêche Ctrl+S de geler le terminal)
+  // et désactiver le caractère discard (Ctrl+O) que le terminal intercepte sinon
+  if (process.stdout.isTTY) {
+    try { execSync('stty sane', { stdio: 'ignore' }); } catch {}
+    try { execSync('stty -ixon', { stdio: 'ignore' }); } catch {}
+    try { execSync('stty discard undef', { stdio: 'ignore' }); } catch {}
+  }
+
+  // Restauration du terminal en cas de signal inattendu
+  const restoreTerminal = () => {
+    try {
+      disableMouseReporting();
+      process.stdout.write('\x1B[?25h');
+      process.stdout.write('\x1B[?7h');
+      if (process.stdin.isTTY) process.stdin.setRawMode?.(false);
+      if (process.stdout.isTTY) {
+        try { execSync('stty sane', { stdio: 'ignore' }); } catch {}
+        try { execSync('stty -ixon', { stdio: 'ignore' }); } catch {}
+        try { execSync('stty discard undef', { stdio: 'ignore' }); } catch {}
+      }
+    } catch {}
+  };
+
+  const sigHandler = () => {
+    let savedId = null;
+    if (agentLoopRef) {
+      try {
+        const history = agentLoopRef.getConversationHistory();
+        if (history?.length > 0) {
+          const sm = new SessionManager({ server: agentConfig.server, token: agentConfig.token });
+          savedId = sm.generateSessionId();
+          sm.saveLocalSync(savedId, {
+            title: `Session ${savedId}`,
+            conversationHistory: history,
+            mode: agentConfig.mode,
+            os: agentConfig.device,
+            local: agentConfig.local,
+          });
+        }
+      } catch {}
+    }
+    restoreTerminal();
+    if (savedId) {
+      process.stdout.write(`\n${chalk.dim('Session saved. Resume with:')} osai-agent run ${savedId}\n\n`);
+    }
+    process.exit(0);
+  };
+  process.prependListener('SIGINT', sigHandler);
+  process.prependListener('SIGTERM', sigHandler);
+
+  process.stdout.write('\x1Bc');
+  await new Promise(r => setTimeout(r, 100));
+  // [FIX-4] Throttle adaptatif : sur Linux, on abaisse la cadence de rendu à 10 fps
+  // pour éviter le scintillement (redraw complet trop fréquent). OSAI_MAX_FPS permet
+  // d'override depuis l'environnement (ex: OSAI_MAX_FPS=8 sur un terminal très lent).
+  const isLinux = process.platform === 'linux';
+  const envFps = Number.parseInt(process.env.OSAI_MAX_FPS || '', 10);
+  const maxFps = Number.isFinite(envFps) && envFps > 0 ? envFps : (isLinux ? 10 : 15);
+  logger.debug('Render config', { maxFps, platform: process.platform, isTTY: !!process.stdout.isTTY });
+
+  let clear, waitUntilExit;
+  try {
+    ({ clear, waitUntilExit } = render(h(App, {
+    createAgentLoop,
+    agentConfig,
+    initialSession: fromSession || null,
+    onExit: () => {
+      clear();
+      restoreTerminal();
+      process.removeListener('SIGINT', sigHandler);
+      process.removeListener('SIGTERM', sigHandler);
+      if (agentLoopRef) {
+        try { agentLoopRef.cleanup(); } catch {}
+      }
+      process.exit(0);
+    }
+  }), {
+    incrementalRendering: true,
+    maxFps,
+  }));
+  } catch {
+    restoreTerminal();
+    process.exit(1);
+  }
+
+  // Ink appelle setRawMode(true) en interne, ce qui peut réactiver IXON.
+  // On re-désactive XON/XOFF après l'initialisation pour garantir la fluidité de l'input.
+  // On re-désactive aussi discard (Ctrl+O) que le terminal intercepte sinon.
+  if (process.stdout.isTTY) {
+    try { execSync('stty -ixon', { stdio: 'ignore' }); } catch {}
+    try { execSync('stty discard undef', { stdio: 'ignore' }); } catch {}
+  }
+
+  await waitUntilExit;
+};

package/src/commands/search.js

@@ -0,0 +1,64 @@
+import chalk from 'chalk';
+import Conf from 'conf';
+import { printError, printSuccess, printInfo } from '../ui/terminal.js';
+
+const getConfig = () => new Conf({ projectName: 'osai-agent' });
+
+const SEARCH_PROVIDERS = ['serpapi', 'tavily'];
+
+const maskKey = (key) => {
+  if (!key) return null;
+  if (key.length <= 4) return key;
+  return key.slice(0, 3) + '...' + key.slice(-4);
+};
+
+export const searchSet = async (provider, options) => {
+  if (!provider) {
+    printError('Usage: osai-agent search set <provider> --key <key>');
+    return;
+  }
+
+  const normalized = provider.toLowerCase();
+  if (!SEARCH_PROVIDERS.includes(normalized)) {
+    printError(`Unknown search provider: ${provider}. Supported: ${SEARCH_PROVIDERS.join(', ')}`);
+    return;
+  }
+
+  const key = options.key || options.k;
+  if (!key) {
+    printError(`Usage: osai-agent search set ${provider} --key <key>`);
+    return;
+  }
+
+  const config = getConfig();
+  const searchKeys = config.get('searchApiKeys', {});
+  searchKeys[normalized] = key;
+  config.set('searchApiKeys', searchKeys);
+
+  printSuccess(`Search API key saved for ${normalized} | Key: ${maskKey(key)}`);
+};
+
+export const searchList = async () => {
+  const config = getConfig();
+  const searchKeys = config.get('searchApiKeys', {});
+
+  console.log();
+  console.log(chalk.hex('#7aa2f7').bold('  Search Providers'));
+  console.log(chalk.hex('#565f89')('  ─'.repeat(32)));
+
+  if (Object.keys(searchKeys).length === 0) {
+    console.log(chalk.hex('#565f89')('  No search API keys configured.'));
+    console.log(chalk.hex('#565f89')(`  Use: osai-agent search set <provider> --key <key>`));
+    console.log();
+    return;
+  }
+
+  for (const [provider, key] of Object.entries(searchKeys)) {
+    const ddgInfo = provider === 'serpapi' || provider === 'tavily' ? '' : '';
+    console.log(`  ${chalk.white(provider.padEnd(20))} ${chalk.gray(maskKey(key))}`);
+  }
+
+  console.log(chalk.hex('#565f89')('  ─'.repeat(32)));
+  console.log(chalk.gray('  DuckDuckGo is always available (no key needed)'));
+  console.log();
+};

package/src/commands/session.js

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+import { SessionManager } from '../services/session.js';
+import { printInfo, printError, printSuccess } from '../ui/terminal.js';
+import { run } from './run.js';
+
+const sessionManager = new SessionManager();
+
+export const manageSessions = async (subcommand, rest) => {
+  switch (subcommand) {
+    case 'list': {
+      const sessions = await sessionManager.listAll();
+      if (!sessions.length) { printInfo('No saved sessions'); return; }
+      console.log();
+      for (const s of sessions) {
+        const date = new Date(s.savedAt).toLocaleString();
+        console.log(chalk.hex('#7aa2f7')(`  ${s.id}`) + chalk.hex('#565f89')(`  ${s.mode} · ${s.os} · ${s.messageCount} msgs · ${date}`));
+      }
+      console.log();
+      break;
+    }
+    case 'export': {
+      const sessionId = rest[0];
+      if (!sessionId) { printError('Usage: osai-agent session export <id>'); return; }
+      const content = await sessionManager.exportSession(sessionId, rest[1] || 'markdown');
+      if (!content) { printError('Session not found'); return; }
+      console.log(content);
+      break;
+    }
+    case 'delete': {
+      const sessionId = rest[0];
+      if (!sessionId) { printError('Usage: osai-agent session delete <id>'); return; }
+      const deleted = await sessionManager.deleteSession(sessionId);
+      if (deleted) printSuccess('Session deleted');
+      else printError('Session not found');
+      break;
+    }
+    case 'load': {
+      const sessionId = rest[0];
+      if (!sessionId) { printError('Usage: osai-agent session load <id>'); return; }
+      const sessionData = await sessionManager.load(sessionId);
+      if (!sessionData) { printError(`Session not found: ${sessionId}`); return; }
+      printSuccess(`Resuming session: ${sessionId} (${sessionData.mode || 'GENERAL'}, ${sessionData.messageCount || (sessionData.conversationHistory?.length || 0)} messages)`);
+      const serverOverride = rest.find(a => a.startsWith('--server='))?.split('=')[1];
+      await run({ server: serverOverride, fromSession: { ...sessionData, id: sessionId } });
+      break;
+    }
+    default: {
+      console.log();
+      console.log(chalk.hex('#7aa2f7').bold('Session Management'));
+      console.log(chalk.hex('#565f89')('  osai-agent session list          - List saved sessions'));
+      console.log(chalk.hex('#565f89')('  osai-agent session export <id>   - Export session (markdown/json)'));
+      console.log(chalk.hex('#565f89')('  osai-agent session delete <id>   - Delete a session'));
+      console.log(chalk.hex('#565f89')('  osai-agent session load <id>     - Resume a session'));
+      console.log();
+    }
+  }
+};

package/src/commands/skills.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import { discoverSkills, loadSkill, formatSkillsList, invalidateSkillsCache } from '../skills/loader.js';
+import { printError } from '../ui/terminal.js';
+
+export async function manageSkills(subcommand, args = []) {
+  invalidateSkillsCache();
+  const skills = await discoverSkills({ refresh: true });
+
+  switch (subcommand) {
+    case 'list': {
+      console.log();
+      console.log(chalk.hex('#7aa2f7').bold('Available Skills'));
+      console.log();
+      if (!skills.length) {
+        console.log(chalk.gray('  No skills found.'));
+        console.log(chalk.gray('  Create: ~/.osai-agent/skills/<name>/SKILL.md'));
+        console.log(chalk.gray('      or: .osai-agent/skills/<name>/SKILL.md'));
+      } else {
+        for (const s of skills) {
+          console.log(`  ${chalk.white(s.name.padEnd(24))}${chalk.gray(s.description)}`);
+          console.log(chalk.hex('#565f89')(`    [${s.source}] ${s.path}`));
+        }
+      }
+      console.log();
+      break;
+    }
+
+    case 'show': {
+      const name = args[0];
+      if (!name) {
+        printError('Usage: osai-agent skills show <name>');
+        process.exit(1);
+      }
+      const result = await loadSkill(name);
+      if (!result.success) {
+        printError(result.error);
+        process.exit(1);
+      }
+      console.log(result.output);
+      break;
+    }
+
+    default:
+      console.log();
+      console.log(chalk.hex('#7aa2f7').bold('Skills Management'));
+      console.log(chalk.hex('#565f89')('  osai-agent skills list          - List discovered skills'));
+      console.log(chalk.hex('#565f89')('  osai-agent skills show <name>   - Show skill content'));
+      console.log();
+      console.log(chalk.gray('  Skill directories:'));
+      console.log(chalk.gray('    ~/.osai-agent/skills/<name>/SKILL.md'));
+      console.log(chalk.gray('    .osai-agent/skills/<name>/SKILL.md'));
+      console.log();
+  }
+}

package/src/commands/stop-subagent.js

@@ -0,0 +1,58 @@
+import Conf from 'conf';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import { showConfig } from './config.js';
+import { clearScreen, printError, printPanel } from '../ui/terminal.js';
+import { logger } from '../utils/logger.js';
+import { ENV_VARS, APP_VERSION } from '../utils/constants.js';
+import { execSync } from 'child_process';
+import ora from 'ora';
+
+export const stopSubagent = async ({ server }) => {
+  clearScreen();
+  // Show header similar to other commands
+  const config = new Conf({ projectName: 'osai-agent' });
+  const token = config.get('token');
+  const serverUrl = server || config.get('server') || 'https://agent.osai.dev';
+  // Default from env
+  const authDot = token ? chalk.green('●') : chalk.red('○');
+  const authLabel = token ? 'Authenticated' : 'Not authenticated';
+  const serverHost = serverUrl.replace(/^ws(s?):\/\//, '');
+  const headerContent = [
+    ` ${chalk.hex('#4a9eff').bold('OS AI AGENT')} ${chalk.gray(`v${APP_VERSION}`)}`,
+    '',
+    ` ${chalk.hex('#8ab4d8')('Your AI sysadmin, network engineer & senior developer')}`,
+    '',
+    ` ${authDot} ${chalk.hex('#8ab4d8')('Auth:')} ${chalk.white(authLabel)} ${chalk.hex('#8ab4d8')('Server:')} ${chalk.white(serverHost)}`,
+  ].join('\n');
+  console.log(boxen(headerContent, { padding: { left: 3, right: 3 }, margin: { top: 1, bottom: 1 }, borderStyle: 'round', borderColor: '#4a9eff', float: 'center', }));
+  
+  if (!token) {
+    printError('You need to be logged in to stop a subagent. Please run "osai-agent login" first.');
+    return;
+  }
+  
+  const spinner = ora('Stopping subagent...').start();
+  try {
+    const response = await fetch(`${serverUrl}/agent/stop-subagent`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`
+      }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      spinner.fail(`Failed to stop subagent: ${response.status} - ${error}`);
+      console.error(chalk.red(`Error: ${response.status} - ${error}`));
+      process.exit(1);
+    }
+    const result = await response.json();
+    spinner.succeeded(result.message || 'Subagent stop requested');
+    console.log(chalk.green('✓ Subagent stop command sent successfully'));
+  } catch (error) {
+    spinner.fail(`Failed to stop subagent: ${error.message}`);
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+};

package/src/index.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+import { run } from './commands/run.js';
+import { login } from './commands/login.js';
+import { register } from './commands/register.js';
+import { logout } from './commands/logout.js';
+import { connect } from './commands/connect.js';
+import { listDevices, addDevice, removeDevice } from './commands/devices.js';
+import { showConfig, showVersion, setOS, showOS } from './commands/config.js';
+import {
+  setProvider,
+  showProviderModels,
+  showProvider,
+  resetProvider,
+  addCustomProvider,
+  listProviders,
+  listConfiguredProviders,
+  changeModel,
+  changeKey,
+  switchProvider,
+} from './commands/provider.js';
+import { manageSessions } from './commands/session.js';
+import { searchSet, searchList } from './commands/search.js';
+import { manageSkills } from './commands/skills.js';
+import { handleMcpCommand } from './commands/mcp.js';
+import { stopSubagent } from './commands/stop-subagent.js';
+import minimist from 'minimist';
+
+const args = minimist(process.argv.slice(2));
+const cmd = args._[0];
+
+switch (cmd) {
+  case 'run':
+    await run({
+      server: args.server,
+      noConfirm: args['no-confirm'],
+      osOverride: args.os,
+      coding: args.coding,
+      fromSession: args['from-session'],
+      local: args.local,
+    });
+    break;
+
+  case 'login':
+    await login({ server: args.server });
+    break;
+
+  case 'register':
+    await register({ server: args.server });
+    break;
+
+  case 'logout':
+    logout();
+    break;
+
+  case 'connect':
+    await connect({
+      device: args.device,
+      server: args.server,
+      noConfirm: args['no-confirm'],
+    });
+    break;
+
+  case 'devices':
+    if (args._[1] === 'add') {
+      await addDevice();
+    } else if (args._[1] === 'remove') {
+      await removeDevice(args._[2]);
+    } else {
+      await listDevices();
+    }
+    break;
+
+  case 'config':
+    if (args._[1] === 'os') {
+      if (args._[2]) {
+        await setOS(args._[2]);
+      } else {
+        showOS();
+      }
+    } else if (args._[1]) {
+      showConfig(args._[1]);
+    } else {
+      showConfig();
+    }
+    break;
+
+  case 'version':
+  case '--version':
+    showVersion();
+    break;
+
+  case 'provider':
+    await handleProviderCommand(args);
+    break;
+
+  case 'session':
+  case 'sessions':
+    await manageSessions(args._[1], args._.slice(2));
+    break;
+
+  case 'search':
+    if (args._[1] === 'set') {
+      await searchSet(args._[2], args);
+    } else {
+      await searchList();
+    }
+    break;
+
+  case 'skills':
+    await manageSkills(args._[1], args._.slice(2));
+    break;
+
+  case 'mcp':
+    await handleMcpCommand(args);
+    break;
+
+  case 'stop-subagent':
+    await stopSubagent({ server: args.server });
+    break;
+
+  default:
+    if (cmd) {
+      console.error(`Unknown command: ${cmd}`);
+    }
+    console.log();
+    console.log('Usage: osai-agent <command> [options]');
+    console.log();
+    console.log('Commands:');
+    console.log('  run             Start the interactive agent');
+    console.log('  login           Authenticate with the server');
+    console.log('  register        Create a new account');
+    console.log('  logout          Clear authentication');
+    console.log('  connect         Connect to a remote device');
+    console.log('  devices         Manage remote devices');
+    console.log('  config          View or change configuration');
+    console.log('  version         Show version');
+    console.log('  provider        Manage provider settings');
+    console.log('  session         Manage conversation sessions');
+    console.log('  search          Configure search provider');
+    console.log('  skills          Manage skills');
+    console.log('  mcp             Manage MCP servers');
+    console.log('  stop-subagent   Stop a running subagent');
+    console.log();
+    process.exit(cmd ? 1 : 0);
+}
+
+async function handleProviderCommand(args) {
+  const sub = args._[1];
+
+  switch (sub) {
+    case 'set':
+      await setProvider(args._[2], {
+        key: args.key,
+        model: args.model,
+        url: args.url,
+      });
+      break;
+    case 'models':
+      await showProviderModels(args._[2]);
+      break;
+    case 'show':
+      await showProvider();
+      break;
+    case 'reset':
+      await resetProvider();
+      break;
+    case 'custom':
+      await addCustomProvider({
+        name: args.name,
+        key: args.key,
+        url: args.url,
+        model: args.model,
+      });
+      break;
+    case 'list':
+      await listProviders();
+      break;
+    case 'configured':
+      await listConfiguredProviders();
+      break;
+    case 'model':
+      await changeModel(args._[2], args._[3]);
+      break;
+    case 'key':
+      await changeKey(args._[2], args._[3]);
+      break;
+    case 'switch':
+      await switchProvider(args._[2]);
+      break;
+    default:
+      console.log();
+      console.log('Usage: osai-agent provider <subcommand> [options]');
+      console.log();
+      console.log('Subcommands:');
+      console.log('  set <type>         Set provider (--key, --model, --url)');
+      console.log('  models <type>      List available models for a provider');
+      console.log('  show               Show current provider');
+      console.log('  reset              Reset to default provider');
+      console.log('  custom             Add custom provider (--name, --key, --url, --model)');
+      console.log('  list               List available providers');
+      console.log('  configured         List configured providers');
+      console.log('  model <type> <m>   Change model for a configured provider');
+      console.log('  key <type> <k>     Change API key for a configured provider');
+      console.log('  switch <type>      Switch to a configured provider');
+      console.log();
+  }
+}