@shykaruu/jarvis-brain 0.4.0

package/src/cli/deps.ts

@@ -0,0 +1,449 @@
+/**
+ * System Dependency Checker & Installer
+ *
+ * Detects and offers to install system dependencies during onboard:
+ * - Chromium/Chrome browser (all platforms)
+ * - Linux X11 tools: xdotool, xprop, imagemagick (Linux/WSL)
+ * - Google OAuth tokens (optional, all platforms)
+ */
+
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { spawnSync } from 'bun';
+import { c, printOk, printWarn, printErr, printInfo, askYesNo, ask, askSecret, startSpinner, detectPlatform } from './helpers.ts';
+import { LINUX_BROWSER_PATHS, MACOS_BROWSER_PATHS, type BrowserExecutable } from '../actions/browser/chrome-launcher.ts';
+
+export type DepStatus = {
+  name: string;
+  found: boolean;
+  path?: string;
+  message: string;
+  installable: boolean;
+};
+
+// ── Detection ─────────────────────────────────────────────────────────
+
+/**
+ * Check if a Chromium-based browser is installed.
+ */
+export function checkBrowser(): DepStatus {
+  const platform = detectPlatform();
+
+  const candidates: BrowserExecutable[] =
+    platform === 'macos' ? MACOS_BROWSER_PATHS : LINUX_BROWSER_PATHS;
+
+  for (const c of candidates) {
+    if (existsSync(c.path)) {
+      return {
+        name: 'Browser (Chrome/Chromium)',
+        found: true,
+        path: c.path,
+        message: `${c.kind} at ${c.path}`,
+        installable: false,
+      };
+    }
+  }
+
+  // On WSL, also check Windows-side browsers
+  if (platform === 'wsl') {
+    const wslPaths = [
+      '/mnt/c/Program Files/Google/Chrome/Application/chrome.exe',
+      '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe',
+      '/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe',
+      '/mnt/c/Program Files/Microsoft/Edge/Application/msedge.exe',
+    ];
+    for (const p of wslPaths) {
+      if (existsSync(p)) {
+        return {
+          name: 'Browser (Chrome/Chromium)',
+          found: true,
+          path: p,
+          message: `Windows browser at ${p}`,
+          installable: false,
+        };
+      }
+    }
+  }
+
+  return {
+    name: 'Browser (Chrome/Chromium)',
+    found: false,
+    message: 'Not found',
+    installable: true,
+  };
+}
+
+/**
+ * Check for Linux X11 tools needed for app control.
+ */
+export function checkLinuxTools(): DepStatus[] {
+  const platform = detectPlatform();
+  if (platform === 'macos') return []; // Not needed on macOS
+
+  const tools = [
+    { name: 'xdotool', pkg: 'xdotool', desc: 'keyboard/mouse automation' },
+    { name: 'xprop', pkg: 'x11-utils', desc: 'window property inspection' },
+    { name: 'import (ImageMagick)', cmd: 'import', pkg: 'imagemagick', desc: 'screenshot capture' },
+  ];
+
+  return tools.map(tool => {
+    const cmd = tool.cmd ?? tool.name;
+    const result = spawnSync(['which', cmd], { stdout: 'pipe', stderr: 'pipe' });
+    const found = result.exitCode === 0;
+    const path = found ? result.stdout.toString().trim() : undefined;
+
+    return {
+      name: tool.name,
+      found,
+      path,
+      message: found ? path! : `Not installed (${tool.desc})`,
+      installable: true,
+    };
+  });
+}
+
+/**
+ * Check if Google OAuth tokens exist.
+ */
+export function checkGoogleAuth(): DepStatus {
+  const tokensPath = join(homedir(), '.jarvis', 'google-tokens.json');
+  const found = existsSync(tokensPath);
+
+  return {
+    name: 'Google OAuth',
+    found,
+    path: found ? tokensPath : undefined,
+    message: found ? 'Tokens exist' : 'Not configured (optional, for Gmail/Calendar)',
+    installable: true,
+  };
+}
+
+// ── Installation ──────────────────────────────────────────────────────
+
+/**
+ * Detect the system package manager.
+ */
+function detectPackageManager(): 'apt' | 'dnf' | 'pacman' | 'brew' | null {
+  if (spawnSync(['which', 'apt'], { stdout: 'pipe' }).exitCode === 0) return 'apt';
+  if (spawnSync(['which', 'dnf'], { stdout: 'pipe' }).exitCode === 0) return 'dnf';
+  if (spawnSync(['which', 'pacman'], { stdout: 'pipe' }).exitCode === 0) return 'pacman';
+  if (spawnSync(['which', 'brew'], { stdout: 'pipe' }).exitCode === 0) return 'brew';
+  return null;
+}
+
+/**
+ * Install a Chromium-based browser.
+ */
+export async function installBrowser(): Promise<boolean> {
+  const platform = detectPlatform();
+  const pm = detectPackageManager();
+
+  if (platform === 'macos') {
+    if (pm === 'brew') {
+      console.log(c.dim('  Running: brew install --cask google-chrome'));
+      const result = spawnSync(['brew', 'install', '--cask', 'google-chrome'], {
+        stdout: 'inherit', stderr: 'inherit',
+      });
+      return result.exitCode === 0;
+    }
+    printInfo('Install Chrome from: https://www.google.com/chrome/');
+    return false;
+  }
+
+  // Linux / WSL — install a Linux browser (preferred for CDP)
+  if (pm === 'apt') {
+    // Try chromium-browser first (most common on Ubuntu/Debian), then chromium
+    console.log(c.dim('  Running: sudo apt install -y chromium-browser'));
+    let result = spawnSync(['sudo', 'apt', 'install', '-y', 'chromium-browser'], {
+      stdout: 'inherit', stderr: 'inherit',
+    });
+    if (result.exitCode === 0) return true;
+
+    console.log(c.dim('  Trying: sudo apt install -y chromium'));
+    result = spawnSync(['sudo', 'apt', 'install', '-y', 'chromium'], {
+      stdout: 'inherit', stderr: 'inherit',
+    });
+    return result.exitCode === 0;
+  }
+
+  if (pm === 'dnf') {
+    console.log(c.dim('  Running: sudo dnf install -y chromium'));
+    const result = spawnSync(['sudo', 'dnf', 'install', '-y', 'chromium'], {
+      stdout: 'inherit', stderr: 'inherit',
+    });
+    return result.exitCode === 0;
+  }
+
+  if (pm === 'pacman') {
+    console.log(c.dim('  Running: sudo pacman -S --noconfirm chromium'));
+    const result = spawnSync(['sudo', 'pacman', '-S', '--noconfirm', 'chromium'], {
+      stdout: 'inherit', stderr: 'inherit',
+    });
+    return result.exitCode === 0;
+  }
+
+  printInfo('Install Chromium manually for your distribution.');
+  return false;
+}
+
+/**
+ * Install missing Linux X11 tools.
+ */
+export async function installLinuxTools(missing: string[]): Promise<boolean> {
+  const pm = detectPackageManager();
+
+  // Map tool names to package names
+  const pkgMap: Record<string, Record<string, string>> = {
+    apt: { xdotool: 'xdotool', xprop: 'x11-utils', 'import (ImageMagick)': 'imagemagick' },
+    dnf: { xdotool: 'xdotool', xprop: 'xprop', 'import (ImageMagick)': 'ImageMagick' },
+    pacman: { xdotool: 'xdotool', xprop: 'xorg-xprop', 'import (ImageMagick)': 'imagemagick' },
+  };
+
+  if (!pm || pm === 'brew') {
+    printInfo('Install manually: ' + missing.join(', '));
+    return false;
+  }
+
+  const packages = missing
+    .map(name => pkgMap[pm]?.[name])
+    .filter(Boolean) as string[];
+
+  if (packages.length === 0) return true;
+
+  const unique = [...new Set(packages)];
+
+  if (pm === 'apt') {
+    console.log(c.dim(`  Running: sudo apt install -y ${unique.join(' ')}`));
+    const result = spawnSync(['sudo', 'apt', 'install', '-y', ...unique], {
+      stdout: 'inherit', stderr: 'inherit',
+    });
+    return result.exitCode === 0;
+  }
+
+  if (pm === 'dnf') {
+    console.log(c.dim(`  Running: sudo dnf install -y ${unique.join(' ')}`));
+    const result = spawnSync(['sudo', 'dnf', 'install', '-y', ...unique], {
+      stdout: 'inherit', stderr: 'inherit',
+    });
+    return result.exitCode === 0;
+  }
+
+  if (pm === 'pacman') {
+    console.log(c.dim(`  Running: sudo pacman -S --noconfirm ${unique.join(' ')}`));
+    const result = spawnSync(['sudo', 'pacman', '-S', '--noconfirm', ...unique], {
+      stdout: 'inherit', stderr: 'inherit',
+    });
+    return result.exitCode === 0;
+  }
+
+  return false;
+}
+
+/**
+ * Run inline Google OAuth setup flow.
+ */
+export async function setupGoogleOAuth(config: any): Promise<boolean> {
+  let clientId = config.google?.client_id ?? '';
+  let clientSecret = config.google?.client_secret ?? '';
+
+  if (!clientId || !clientSecret) {
+    printInfo('Google OAuth requires OAuth2 credentials from Google Cloud Console.');
+    printInfo('1. Go to https://console.cloud.google.com/apis/credentials');
+    printInfo('2. Create an OAuth2 client ID (Web application)');
+    printInfo('3. Add redirect URI: http://localhost:3142/api/auth/google/callback');
+    console.log('');
+
+    clientId = await ask('Google OAuth Client ID (or press Enter to skip)');
+    if (!clientId) return false;
+
+    clientSecret = await askSecret('Google OAuth Client Secret');
+    if (!clientSecret) return false;
+
+    // Save credentials to config
+    config.google = { ...config.google, client_id: clientId, client_secret: clientSecret };
+  }
+
+  // Import GoogleAuth and start inline flow
+  const { GoogleAuth } = await import('../integrations/google-auth.ts');
+  const auth = new GoogleAuth(clientId, clientSecret);
+
+  if (auth.isAuthenticated()) {
+    printOk('Already authenticated with Google!');
+    return true;
+  }
+
+  const SCOPES = [
+    'https://www.googleapis.com/auth/gmail.readonly',
+    'https://www.googleapis.com/auth/calendar.readonly',
+  ];
+
+  const authUrl = auth.getAuthUrl(SCOPES);
+
+  console.log('');
+  printInfo('Opening browser for Google authorization...');
+  console.log(c.dim(`  ${authUrl}`));
+  console.log('');
+
+  // Try to open browser
+  try {
+    const platform = detectPlatform();
+    if (platform === 'macos') {
+      spawnSync(['open', authUrl], { stdout: 'ignore', stderr: 'ignore' });
+    } else if (platform === 'wsl') {
+      spawnSync(['wslview', authUrl], { stdout: 'ignore', stderr: 'ignore' });
+    } else {
+      spawnSync(['xdg-open', authUrl], { stdout: 'ignore', stderr: 'ignore' });
+    }
+  } catch {
+    // User can open manually
+  }
+
+  // Start temporary callback server for OAuth redirect
+  printInfo('Waiting for authorization callback on port 3142...');
+
+  return new Promise<boolean>((resolve) => {
+    let server: ReturnType<typeof Bun.serve>;
+    try {
+      server = Bun.serve({
+        port: 3142,
+        async fetch(req) {
+          const url = new URL(req.url);
+
+          if (url.pathname === '/api/auth/google/callback') {
+            const code = url.searchParams.get('code');
+            const error = url.searchParams.get('error');
+
+            if (error) {
+              clearTimeout(timeout);
+              printErr(`Authorization denied: ${error}`);
+              setTimeout(() => { server.stop(); resolve(false); }, 300);
+              return new Response(
+                '<html><body><h1>Authorization Denied</h1><p>You can close this tab.</p></body></html>',
+                { headers: { 'Content-Type': 'text/html' } }
+              );
+            }
+
+            if (!code) {
+              return new Response('Missing code', { status: 400 });
+            }
+
+            try {
+              await auth.exchangeCode(code);
+              clearTimeout(timeout);
+              printOk('Google OAuth configured! Tokens saved.');
+              setTimeout(() => { server.stop(); resolve(true); }, 300);
+              return new Response(
+                '<html><body><h1>JARVIS Google Authorization Complete!</h1><p>You can close this tab.</p></body></html>',
+                { headers: { 'Content-Type': 'text/html' } }
+              );
+            } catch (err) {
+              clearTimeout(timeout);
+              printErr(`Token exchange failed: ${err}`);
+              setTimeout(() => { server.stop(); resolve(false); }, 300);
+              return new Response(
+                `<html><body><h1>Token Exchange Failed</h1><pre>${err}</pre></body></html>`,
+                { headers: { 'Content-Type': 'text/html' }, status: 500 }
+              );
+            }
+          }
+
+          return new Response('Not found', { status: 404 });
+        },
+      });
+    } catch (err) {
+      printErr(`Could not start OAuth callback server on port 3142 (port in use?)`);
+      printInfo('Stop the JARVIS daemon first, or run later with: bun run setup:google');
+      resolve(false);
+      return;
+    }
+
+    const timeout = setTimeout(() => {
+      server.stop();
+      printWarn('Timeout waiting for Google authorization (60s).');
+      printInfo('Run later with: bun run setup:google');
+      resolve(false);
+    }, 60_000);
+  });
+}
+
+// ── Main Step Runner ──────────────────────────────────────────────────
+
+/**
+ * Run the full dependency check + install flow.
+ * Called as Step 3 of the onboard wizard.
+ */
+export async function runDependencyCheck(config: any): Promise<void> {
+  // Collect all dependency statuses
+  const deps: DepStatus[] = [];
+
+  deps.push(checkBrowser());
+
+  const linuxTools = checkLinuxTools();
+  deps.push(...linuxTools);
+
+  deps.push(checkGoogleAuth());
+
+  // Display status table
+  console.log('');
+  for (const dep of deps) {
+    const icon = dep.found ? c.green('\u2713') : c.red('\u2717');
+    const name = dep.name.padEnd(26);
+    const detail = dep.found
+      ? c.dim(dep.path ?? dep.message)
+      : c.yellow(dep.message);
+    console.log(`  ${icon} ${name} ${detail}`);
+  }
+  console.log('');
+
+  const missing = deps.filter(d => !d.found && d.installable);
+
+  if (missing.length === 0) {
+    printOk('All system dependencies are satisfied!');
+    return;
+  }
+
+  printInfo(`${missing.length} optional ${missing.length === 1 ? 'dependency' : 'dependencies'} not found.`);
+  console.log('');
+
+  // Offer to install each missing dependency
+  // Group: browser
+  const missingBrowser = missing.find(d => d.name.includes('Browser'));
+  if (missingBrowser) {
+    const install = await askYesNo('Install a Chromium-based browser?', true);
+    if (install) {
+      const ok = await installBrowser();
+      if (ok) printOk('Browser installed!');
+      else printWarn('Browser install incomplete. Install manually later.');
+    } else {
+      printInfo('Skip. Install later: sudo apt install chromium-browser');
+    }
+  }
+
+  // Group: Linux tools (batch install)
+  const missingLinux = missing.filter(d =>
+    d.name === 'xdotool' || d.name === 'xprop' || d.name === 'import (ImageMagick)'
+  );
+  if (missingLinux.length > 0) {
+    const names = missingLinux.map(d => d.name).join(', ');
+    const install = await askYesNo(`Install Linux tools (${names})?`, true);
+    if (install) {
+      const ok = await installLinuxTools(missingLinux.map(d => d.name));
+      if (ok) printOk('Linux tools installed!');
+      else printWarn('Some tools may not have installed. Check manually.');
+    } else {
+      printInfo('Skip. Install later: sudo apt install xdotool x11-utils imagemagick');
+    }
+  }
+
+  // Group: Google OAuth (special — only if user has google config or wants to set up)
+  const missingGoogle = missing.find(d => d.name === 'Google OAuth');
+  if (missingGoogle) {
+    const install = await askYesNo('Set up Google OAuth for Gmail/Calendar? (optional)', false);
+    if (install) {
+      await setupGoogleOAuth(config);
+    } else {
+      printInfo('Skip. Set up later with: bun run setup:google');
+    }
+  }
+}

package/src/cli/doctor.ts

@@ -0,0 +1,238 @@
+/**
+ * J.A.R.V.I.S. Doctor — Environment Diagnostics
+ *
+ * Checks system requirements, configuration, and connectivity.
+ */
+
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { existsSync, readFileSync } from 'node:fs';
+import {
+  c, printBanner, printOk, printWarn, printErr, printInfo, startSpinner, closeRL,
+} from './helpers.ts';
+
+const JARVIS_DIR = join(homedir(), '.jarvis');
+const CONFIG_PATH = join(JARVIS_DIR, 'config.yaml');
+
+interface CheckResult {
+  name: string;
+  status: 'ok' | 'warn' | 'fail' | 'skip';
+  message: string;
+}
+
+export async function runDoctor(): Promise<void> {
+  printBanner();
+  console.log(c.bold('Running system diagnostics...\n'));
+
+  const results: CheckResult[] = [];
+
+  // ── Check 1: Bun Version ──────────────────────────────────────────
+
+  const bunVersion = Bun.version;
+  const [major] = bunVersion.split('.').map(Number);
+  if (major! >= 1) {
+    results.push({ name: 'Bun Runtime', status: 'ok', message: `v${bunVersion}` });
+  } else {
+    results.push({ name: 'Bun Runtime', status: 'warn', message: `v${bunVersion} (>= 1.0.0 recommended)` });
+  }
+
+  // ── Check 2: Data Directory ───────────────────────────────────────
+
+  if (existsSync(JARVIS_DIR)) {
+    results.push({ name: 'Data Directory', status: 'ok', message: JARVIS_DIR });
+  } else {
+    results.push({ name: 'Data Directory', status: 'warn', message: `${JARVIS_DIR} not found. Run: jarvis onboard` });
+  }
+
+  // ── Check 3: Config File ──────────────────────────────────────────
+
+  let config: any = null;
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      const YAML = (await import('yaml')).default;
+      const text = readFileSync(CONFIG_PATH, 'utf-8');
+      config = YAML.parse(text);
+      results.push({ name: 'Config File', status: 'ok', message: CONFIG_PATH });
+    } catch (err) {
+      results.push({ name: 'Config File', status: 'fail', message: `Invalid YAML: ${err}` });
+    }
+  } else {
+    results.push({ name: 'Config File', status: 'fail', message: 'Not found. Run: jarvis onboard' });
+  }
+
+  // ── Check 4: LLM API Key ─────────────────────────────────────────
+
+  if (config) {
+    const primary = config.llm?.primary ?? 'anthropic';
+    const providerConfig = config.llm?.[primary];
+
+    if (primary === 'ollama') {
+      results.push({ name: 'LLM Provider', status: 'ok', message: `ollama (${providerConfig?.model ?? 'llama3'})` });
+    } else if (providerConfig?.api_key && providerConfig.api_key !== '') {
+      results.push({
+        name: 'LLM Provider',
+        status: 'ok',
+        message: `${primary} (key: ${providerConfig.api_key.slice(0, 10)}...)`,
+      });
+    } else {
+      results.push({ name: 'LLM Provider', status: 'fail', message: `${primary} API key not set` });
+    }
+  } else {
+    results.push({ name: 'LLM Provider', status: 'skip', message: 'No config file' });
+  }
+
+  // ── Check 5: LLM Connectivity ────────────────────────────────────
+
+  if (config) {
+    const spin = startSpinner('Testing LLM connectivity...');
+    try {
+      const { LLMManager, AnthropicProvider, OpenAIProvider, GroqProvider, GeminiProvider, OllamaProvider, OpenRouterProvider } = await import('../llm/index.ts');
+      const manager = new LLMManager();
+      const primary = config.llm?.primary ?? 'anthropic';
+
+      if (primary === 'anthropic' && config.llm?.anthropic?.api_key) {
+        manager.registerProvider(new AnthropicProvider(config.llm.anthropic.api_key, config.llm.anthropic.model));
+      } else if (primary === 'openai' && config.llm?.openai?.api_key) {
+        manager.registerProvider(new OpenAIProvider(
+          config.llm.openai.api_key,
+          config.llm.openai.model,
+          config.llm.openai.base_url,
+        ));
+      } else if (primary === 'groq' && config.llm?.groq?.api_key) {
+        manager.registerProvider(new GroqProvider(config.llm.groq.api_key, config.llm.groq.model));
+      } else if (primary === 'gemini' && config.llm?.gemini?.api_key) {
+        manager.registerProvider(new GeminiProvider(config.llm.gemini.api_key, config.llm.gemini.model));
+      } else if (primary === 'openrouter' && config.llm?.openrouter?.api_key) {
+        manager.registerProvider(new OpenRouterProvider(config.llm.openrouter.api_key, config.llm.openrouter.model));
+      } else if (primary === 'ollama') {
+        manager.registerProvider(new OllamaProvider(config.llm.ollama?.base_url, config.llm.ollama?.model));
+      }
+
+      manager.setPrimary(primary);
+      const resp = await manager.chat(
+        [{ role: 'user', content: 'Say OK' }],
+        { max_tokens: 10 },
+      );
+      spin.stop();
+      results.push({ name: 'LLM Connectivity', status: 'ok', message: `Model: ${resp.model}` });
+    } catch (err) {
+      spin.stop();
+      results.push({ name: 'LLM Connectivity', status: 'fail', message: String(err).slice(0, 100) });
+    }
+  } else {
+    results.push({ name: 'LLM Connectivity', status: 'skip', message: 'No config file' });
+  }
+
+  // ── Check 6: Browser (Chromium/Chrome) ────────────────────────────
+
+  const browserPaths = process.platform === 'darwin'
+    ? ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', '/Applications/Chromium.app/Contents/MacOS/Chromium']
+    : ['/usr/bin/chromium-browser', '/usr/bin/chromium', '/usr/bin/google-chrome', '/usr/bin/google-chrome-stable'];
+
+  const foundBrowser = browserPaths.find(p => existsSync(p));
+  if (foundBrowser) {
+    results.push({ name: 'Browser', status: 'ok', message: foundBrowser });
+  } else {
+    // Try which
+    const which = Bun.spawnSync(['which', 'chromium-browser']);
+    if (which.exitCode === 0) {
+      results.push({ name: 'Browser', status: 'ok', message: which.stdout.toString().trim() });
+    } else {
+      results.push({ name: 'Browser', status: 'warn', message: 'Chromium/Chrome not found. Browser tools will be limited.' });
+    }
+  }
+
+  // ── Check 7: Port Availability ────────────────────────────────────
+
+  const port = config?.daemon?.port ?? 3142;
+  try {
+    const server = Bun.serve({ port, fetch: () => new Response('') });
+    server.stop(true);
+    results.push({ name: 'Port', status: 'ok', message: `${port} is available` });
+  } catch {
+    results.push({ name: 'Port', status: 'warn', message: `${port} is in use (daemon may already be running)` });
+  }
+
+  // ── Check 8: SQLite ───────────────────────────────────────────────
+
+  try {
+    const { Database } = await import('bun:sqlite');
+    const db = new Database(':memory:');
+    db.run('CREATE TABLE test (id INTEGER PRIMARY KEY)');
+    db.close();
+    results.push({ name: 'SQLite', status: 'ok', message: 'bun:sqlite working' });
+  } catch (err) {
+    results.push({ name: 'SQLite', status: 'fail', message: String(err) });
+  }
+
+  // ── Check 9: TTS/STT Providers ────────────────────────────────────
+
+  if (config?.tts?.enabled) {
+    results.push({ name: 'TTS', status: 'ok', message: `${config.tts.provider ?? 'edge'} (${config.tts.voice ?? 'default'})` });
+  } else {
+    results.push({ name: 'TTS', status: 'skip', message: 'Disabled' });
+  }
+
+  if (config?.stt?.provider) {
+    const sttProv = config.stt.provider;
+    const hasKey = sttProv === 'ollama' || sttProv === 'local'
+      || (sttProv === 'openai' && config.stt.openai?.api_key)
+      || (sttProv === 'groq' && config.stt.groq?.api_key);
+    results.push({
+      name: 'STT',
+      status: hasKey ? 'ok' : 'warn',
+      message: hasKey ? `${sttProv} configured` : `${sttProv} (API key missing)`,
+    });
+  } else {
+    results.push({ name: 'STT', status: 'skip', message: 'Not configured' });
+  }
+
+  // ── Check 11: Channels ────────────────────────────────────────────
+
+  if (config?.channels?.telegram?.enabled && config.channels.telegram.bot_token) {
+    results.push({ name: 'Telegram', status: 'ok', message: 'Bot token set' });
+  } else {
+    results.push({ name: 'Telegram', status: 'skip', message: 'Not configured' });
+  }
+
+  if (config?.channels?.discord?.enabled && config.channels.discord.bot_token) {
+    results.push({ name: 'Discord', status: 'ok', message: 'Bot token set' });
+  } else {
+    results.push({ name: 'Discord', status: 'skip', message: 'Not configured' });
+  }
+
+  // ── Results ───────────────────────────────────────────────────────
+
+  console.log(c.bold('\nDiagnostics Results:\n'));
+
+  let okCount = 0;
+  let warnCount = 0;
+  let failCount = 0;
+
+  for (const r of results) {
+    const icon = r.status === 'ok' ? c.green('✓')
+      : r.status === 'warn' ? c.yellow('!')
+      : r.status === 'fail' ? c.red('✗')
+      : c.dim('○');
+
+    const nameStr = r.name.padEnd(20);
+    console.log(`  ${icon} ${nameStr} ${c.dim(r.message)}`);
+
+    if (r.status === 'ok') okCount++;
+    else if (r.status === 'warn') warnCount++;
+    else if (r.status === 'fail') failCount++;
+  }
+
+  console.log('');
+  console.log(`  ${c.green(`${okCount} passed`)}  ${c.yellow(`${warnCount} warnings`)}  ${c.red(`${failCount} failed`)}`);
+
+  if (failCount > 0) {
+    console.log(c.red('\nSome checks failed. Run "jarvis onboard" to fix configuration.\n'));
+  } else if (warnCount > 0) {
+    console.log(c.yellow('\nAll critical checks passed, but some optional features need setup.\n'));
+  } else {
+    console.log(c.green('\nAll checks passed! JARVIS is ready.\n'));
+  }
+
+  closeRL();
+}