osai-agent 4.0.0

package/src/commands/login.js

@@ -0,0 +1,77 @@
+import pkg from 'node-machine-id';
+const { machineIdSync } = pkg;
+import chalk from 'chalk';
+import Conf from 'conf';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { ExitPromptError } from '@inquirer/core';
+import { printAuthHeader, printError, printSuccess, clearScreen } from '../ui/terminal.js';
+import { DEFAULT_SERVER_URL, toHttpUrl, toWsUrl } from '../services/server-url.js';
+import { run } from './run.js';
+
+const attemptLogin = async (email, password, serverInput, config) => {
+  const server = toWsUrl(serverInput);
+  const machineId = machineIdSync();
+  const spinner = ora('Connecting to server...').start();
+
+  try {
+    const response = await fetch(`${toHttpUrl(server)}/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, password, machineId })
+    });
+    const data = await response.json();
+    if (!response.ok) { spinner.fail('Login refused'); printError(data.error || 'Connection error'); return 'auth_error'; }
+    config.set({ token: data.token, userId: data.user.id, plan: data.user.plan, server });
+    spinner.succeed('Session started');
+    printSuccess('Connected');
+    console.log(chalk.gray(`  Plan: ${data.user.plan}`));
+    console.log(chalk.gray(`  Use: osai-agent connect\n`));
+    return 'success';
+  } catch {
+    spinner.fail('Unable to connect');
+    return 'network_error';
+  }
+};
+
+export const login = 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('Welcome Back'), 'Sign in to OS AI Agent to continue.');
+  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: '*' },
+    ]));
+  } catch (err) {
+    if (err instanceof ExitPromptError) process.exit(0);
+    throw err;
+  }
+
+  const result = await attemptLogin(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 attemptLogin(email, password, retryServer, config);
+    if (result2 === 'success') await run({});
+  } catch (err) {
+    if (err instanceof ExitPromptError) process.exit(0);
+    throw err;
+  }
+};

package/src/commands/logout.js

@@ -0,0 +1,31 @@
+import Conf from 'conf';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import ora from 'ora';
+
+export const logout = () => {
+  const config = new Conf({ projectName: 'osai-agent' });
+  const token = config.get('token');
+  if (!token) {
+    console.log(chalk.yellow('Already logged out.'));
+    return;
+  }
+
+  const spinner = ora({ text: 'Logging out...', color: 'blue' }).start();
+
+  setTimeout(() => {
+    config.delete('token');
+    config.delete('userId');
+    config.delete('plan');
+    spinner.succeed('Logged out');
+
+    console.log(boxen(
+      chalk.hex('#7aa2f7').bold('  OS AI Agent') +
+      chalk.hex('#c0caf5')('\n  See you soon!') +
+      chalk.hex('#565f89').dim('\n  You have been logged out.'),
+      { padding: 1, borderStyle: 'round', borderColor: '#4a9eff' }
+    ));
+
+    process.exit(0);
+  }, 1000);
+};

package/src/commands/mcp.js

@@ -0,0 +1,258 @@
+import Conf from 'conf';
+import { mcpClientManager } from '../tools/mcp-client.js';
+
+const config = new Conf({ projectName: 'osai-agent' });
+
+function getServers() {
+  return config.get('mcpServers', {});
+}
+
+function saveServers(servers) {
+  config.set('mcpServers', servers);
+}
+
+export async function handleMcpCommand(args) {
+  const subcommand = args._[1] || 'list';
+
+  switch (subcommand) {
+    case 'list':
+      return listServers();
+    case 'add':
+      return addServer(args);
+    case 'remove':
+      return removeServer(args);
+    case 'reload':
+      return reloadServers();
+    case 'test':
+      return testServer(args);
+    default:
+      console.log('Usage: osai-agent mcp <list|add|remove|reload|test>');
+      console.log('');
+      console.log('  list                                    List all MCP servers and their tools');
+      console.log('  add <name>                              Add a new MCP server (interactive wizard)');
+      console.log('  add <name> --command <cmd> [--args ...]  Add a stdio server via CLI flags');
+      console.log('  add <name> --url <url> [--token <t>]     Add an HTTP server via CLI flags');
+      console.log('  add <name> --url <url> [--header "K=V"]  Add HTTP server with custom headers');
+      console.log('  remove <name>                           Remove an MCP server');
+      console.log('  reload                                  Reload all MCP servers from config');
+      console.log('  test <name>                             Test connection and list its tools');
+  }
+}
+
+async function listServers() {
+  const servers = getServers();
+  const names = Object.keys(servers);
+
+  if (names.length === 0) {
+    console.log('No MCP servers configured.');
+    console.log('Use: osai-agent mcp add <name>');
+    return;
+  }
+
+  console.log(`MCP Servers (${names.length} configured):`);
+  console.log('');
+
+  for (const name of names) {
+    const cfg = servers[name];
+    const conn = mcpClientManager.getServer(name);
+    const status = conn && conn.connected ? '\x1b[32mconnected\x1b[0m' : '\x1b[33mnot connected\x1b[0m';
+    const transport = cfg.transport || 'stdio';
+
+    console.log(`  ${name} [${status}] (${transport})`);
+    if (transport === 'stdio') {
+      console.log(`    command: ${cfg.command} ${(cfg.args || []).join(' ')}`);
+    } else {
+      console.log(`    url: ${cfg.url}`);
+    }
+
+    if (conn && conn.connected) {
+      const tools = conn.tools;
+      if (tools.length > 0) {
+        console.log(`    tools (${tools.length}):`);
+        for (const tool of tools) {
+          console.log(`      - ${tool.name}: ${tool.description || '(no description)'}`);
+        }
+      } else {
+        console.log('    (no tools advertised)');
+      }
+    }
+    console.log('');
+  }
+}
+
+async function addServer(args) {
+  const name = args._[2];
+  if (!name) {
+    console.log('Error: server name required');
+    console.log('Usage: osai-agent mcp add <name> [options]');
+    console.log('');
+    console.log('  Options (stdio):');
+    console.log('    --command <cmd>         Command to run (e.g., node, npx)');
+    console.log('    --args <json|string>    Arguments for the command');
+    console.log('');
+    console.log('  Options (http):');
+    console.log('    --url <url>             Server URL (e.g., http://localhost:3001/mcp)');
+    console.log('    --transport <type>      Transport type: http or streamable-http');
+    console.log('    --token <token>         Bearer token for Authorization header');
+    console.log('    --header <key=value>    Custom header (repeatable)');
+    console.log('');
+    console.log('  Examples:');
+    console.log('    osai-agent mcp add my-api --url http://localhost:3001/mcp --token my-token');
+    console.log('    osai-agent mcp add my-api --url http://localhost:3001/mcp --transport streamable-http');
+    console.log('    osai-agent mcp add my-tool --command npx --args @modelcontextprotocol/server-filesystem');
+    return;
+  }
+
+  const servers = getServers();
+  if (servers[name]) {
+    console.log(`Server "${name}" already exists. Use "osai-agent mcp remove ${name}" first.`);
+    return;
+  }
+
+  let serverConfig;
+
+  // --- Mode CLI flags (non-interactif) ---
+  if (args.url) {
+    const headers = {};
+    if (args.token) headers['Authorization'] = `Bearer ${args.token}`;
+    if (args.header) {
+      const headersList = Array.isArray(args.header) ? args.header : [args.header];
+      for (const h of headersList) {
+        const idx = h.indexOf('=');
+        if (idx > 0) headers[h.slice(0, idx)] = h.slice(idx + 1);
+      }
+    }
+    serverConfig = {
+      transport: args.transport || 'http',
+      url: args.url,
+      ...(Object.keys(headers).length > 0 ? { headers } : {}),
+    };
+  } else if (args.command) {
+    let parsedArgs = [];
+    if (args.args) {
+      try {
+        parsedArgs = typeof args.args === 'string' ? JSON.parse(args.args) : args.args;
+      } catch {
+        parsedArgs = [args.args];
+      }
+    }
+    serverConfig = { transport: 'stdio', command: args.command, args: parsedArgs };
+  }
+
+  // --- Mode interactif ---
+  if (!serverConfig) {
+    const { createInterface } = await import('readline');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(r => rl.question(q, r));
+
+    console.log(`\nAdding MCP server "${name}":`);
+    const transportType = (await ask('  Transport type (stdio/http): ')).trim().toLowerCase();
+
+    if (transportType === 'http' || transportType === 'streamable-http') {
+      const url = await ask('  URL (e.g., http://localhost:3001/mcp): ');
+      const token = await ask('  Bearer token (optional, press Enter to skip): ');
+      const config = { transport: transportType, url: url.trim() };
+      if (token.trim()) config.headers = { Authorization: `Bearer ${token.trim()}` };
+      serverConfig = config;
+    } else {
+      const cmd = await ask('  Command (e.g., node, npx): ');
+      const argsStr = await ask('  Arguments (space-separated): ');
+      const parsedArgs = argsStr ? argsStr.split(' ').filter(Boolean) : [];
+      serverConfig = { transport: 'stdio', command: cmd, args: parsedArgs };
+    }
+    rl.close();
+  }
+
+  servers[name] = serverConfig;
+  saveServers(servers);
+  console.log(`Server "${name}" added to config.`);
+
+  try {
+    const tools = await mcpClientManager.addServer(name, serverConfig);
+    console.log(`Connected: ${tools.length} tools available.`);
+  } catch (err) {
+    console.log(`Warning: could not connect: ${err.message}`);
+    console.log('The server is saved in config and will connect on next agent run.');
+  }
+}
+
+async function removeServer(args) {
+  const name = args._[2];
+  if (!name) {
+    console.log('Error: server name required');
+    console.log('Usage: osai-agent mcp remove <name>');
+    return;
+  }
+
+  const servers = getServers();
+  if (!servers[name]) {
+    console.log(`Server "${name}" not found.`);
+    return;
+  }
+
+  await mcpClientManager.removeServer(name);
+
+  delete servers[name];
+  saveServers(servers);
+  console.log(`Server "${name}" removed.`);
+}
+
+async function reloadServers() {
+  const servers = getServers();
+  const names = Object.keys(servers);
+
+  if (names.length === 0) {
+    console.log('No MCP servers configured.');
+    return;
+  }
+
+  console.log(`Reloading ${names.length} MCP server(s)...`);
+  const results = await mcpClientManager.reload(servers);
+
+  if (results.connected.length > 0) {
+    for (const r of results.connected) {
+      console.log(`  \x1b[32m✓\x1b[0m ${r.name}: ${r.toolCount} tools`);
+    }
+  }
+  if (results.failed.length > 0) {
+    for (const r of results.failed) {
+      console.log(`  \x1b[31m✗\x1b[0m ${r.name}: ${r.error}`);
+    }
+  }
+}
+
+async function testServer(args) {
+  const name = args._[2];
+  if (!name) {
+    console.log('Error: server name required');
+    console.log('Usage: osai-agent mcp test <name>');
+    return;
+  }
+
+  const servers = getServers();
+  const cfg = servers[name];
+  if (!cfg) {
+    console.log(`Server "${name}" not found in config.`);
+    return;
+  }
+
+  console.log(`Testing connection to "${name}"...`);
+
+  try {
+    const tools = await mcpClientManager.addServer(name, cfg);
+    console.log(`\x1b[32m✓ Connected\x1b[0m — ${tools.length} tools:`);
+    for (const tool of tools) {
+      console.log(`  - ${tool.name}: ${tool.description || '(no description)'}`);
+      if (tool.inputSchema) {
+        const props = tool.inputSchema.properties || {};
+        const paramNames = Object.keys(props);
+        if (paramNames.length > 0) {
+          console.log(`    params: ${paramNames.join(', ')}`);
+        }
+      }
+    }
+    await mcpClientManager.removeServer(name);
+  } catch (err) {
+    console.log(`\x1b[31m✗ Connection failed\x1b[0m: ${err.message}`);
+  }
+}