@bsbofmusic/agent-browser-mcp-opencode 0.1.1 → 1.0.0

package/src/doctor.js

@@ -0,0 +1,387 @@
+import { execSync } from 'child_process';
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { runFullDetection } from './detect.js';
+import ensure from './ensure.js';
+const { getAgentBrowserVersion, checkForUpdates } = ensure;
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+
+const LOG_LEVEL = process.env.LOG_LEVEL || 'info';
+
+function log(level, message, data = null) {
+  const levels = { error: 0, warn: 1, info: 2, debug: 3 };
+  if (levels[level] <= levels[LOG_LEVEL]) {
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] [${level.toUpperCase()}] ${message}`, data ? JSON.stringify(data) : '');
+  }
+}
+
+export async function diagnoseNetwork() {
+  const issues = [];
+  const checks = {
+    npmRegistry: false,
+    github: false,
+    google: false,
+  };
+
+  const checkUrl = (url) => {
+    try {
+      const cmd = process.platform === 'win32' 
+        ? `ping -n 1 -w 2000 ${url} > nul 2>&1`
+        : `ping -c 1 -W 2 ${url} > /dev/null 2>&1`;
+      execSync(cmd, { timeout: 5000 });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  checks.npmRegistry = checkUrl('registry.npmjs.org');
+  checks.github = checkUrl('github.com');
+  checks.google = checkUrl('google.com');
+
+  if (!checks.npmRegistry) {
+    issues.push({
+      category: 'network',
+      severity: 'high',
+      message: 'Cannot reach npm registry (registry.npmjs.org)',
+      nextSteps: [
+        'Check internet connection',
+        'Configure npm mirror: npm config set registry https://registry.npmmirror.com',
+        'Check proxy settings: npm config get proxy',
+      ],
+    });
+  }
+
+  if (!checks.github) {
+    issues.push({
+      category: 'network',
+      severity: 'medium',
+      message: 'Cannot reach github.com',
+      nextSteps: ['Check firewall/proxy settings'],
+    });
+  }
+
+  return { checks, issues };
+}
+
+export async function diagnosePermissions() {
+  const issues = [];
+  const checks = {
+    npmGlobalWritable: false,
+    tempWritable: false,
+    homeWritable: false,
+  };
+
+  try {
+    const npmPrefix = execSync('npm config get prefix', { encoding: 'utf8' }).trim();
+    const globalPath = path.join(npmPrefix, 'lib', 'node_modules');
+    try {
+      fs.accessSync(globalPath, fs.constants.W_OK);
+      checks.npmGlobalWritable = true;
+    } catch {
+      checks.npmGlobalWritable = false;
+      issues.push({
+        category: 'permissions',
+        severity: 'high',
+        message: `No write permission to npm global directory: ${globalPath}`,
+        nextSteps: [
+          'Run: sudo chown -R $(whoami) $(npm config get prefix)/lib/node_modules',
+          'Or use npx instead of global install',
+        ],
+      });
+    }
+  } catch (e) {
+    issues.push({
+      category: 'permissions',
+      severity: 'medium',
+      message: 'Cannot determine npm permissions',
+      nextSteps: ['Check npm installation'],
+    });
+  }
+
+  try {
+    const tempDir = os.tmpdir();
+    const testFile = path.join(tempDir, `test-${Date.now()}`);
+    fs.writeFileSync(testFile, 'test');
+    fs.unlinkSync(testFile);
+    checks.tempWritable = true;
+  } catch (e) {
+    checks.tempWritable = false;
+    issues.push({
+      category: 'permissions',
+      severity: 'high',
+      message: 'Cannot write to temp directory',
+      nextSteps: ['Check temp directory permissions', 'Set TMPDIR environment variable'],
+    });
+  }
+
+  try {
+    const homeDir = os.homedir();
+    const testFile = path.join(homeDir, `.test-${Date.now()}`);
+    fs.writeFileSync(testFile, 'test');
+    fs.unlinkSync(testFile);
+    checks.homeWritable = true;
+  } catch (e) {
+    checks.homeWritable = false;
+    issues.push({
+      category: 'permissions',
+      severity: 'high',
+      message: 'Cannot write to home directory',
+      nextSteps: ['Check home directory permissions'],
+    });
+  }
+
+  return { checks, issues };
+}
+
+export async function diagnoseDependencies() {
+  const issues = [];
+  const checks = {
+    nodeInstalled: false,
+    npmInstalled: false,
+    nodeVersion: null,
+    npmVersion: null,
+  };
+
+  try {
+    checks.nodeVersion = process.version;
+    checks.nodeInstalled = true;
+  } catch (e) {
+    issues.push({
+      category: 'dependencies',
+      severity: 'critical',
+      message: 'Node.js is not installed',
+      nextSteps: ['Install Node.js from https://nodejs.org'],
+    });
+  }
+
+  try {
+    checks.npmVersion = execSync('npm --version', { encoding: 'utf8' }).trim();
+    checks.npmInstalled = true;
+  } catch (e) {
+    issues.push({
+      category: 'dependencies',
+      severity: 'critical',
+      message: 'npm is not installed',
+      nextSteps: ['Reinstall Node.js which includes npm'],
+    });
+  }
+
+  if (checks.nodeInstalled) {
+    const [major] = process.version.slice(1).split('.');
+    if (parseInt(major) < 18) {
+      issues.push({
+        category: 'dependencies',
+        severity: 'high',
+        message: `Node.js version ${checks.nodeVersion} is too old (minimum 18.0.0)`,
+        nextSteps: ['Upgrade Node.js to version 18 or higher'],
+      });
+    }
+  }
+
+  return { checks, issues };
+}
+
+export async function diagnoseSystemLibraries() {
+  const issues = [];
+  const checks = {};
+  const platform = os.platform();
+
+  if (platform === 'linux') {
+    checks.linuxDeps = false;
+    
+    try {
+      const result = execSync('ldconfig -p | grep -E "(libx11|libxcomposite|libxdamage|libxrandr|libatk|libatk-bridge|libxkbcommon|libglib)"', { encoding: 'utf8' });
+      checks.linuxDeps = result.trim().length > 0;
+    } catch {
+      issues.push({
+        category: 'system_libraries',
+        severity: 'high',
+        message: 'Missing required Linux system libraries for Chromium',
+        nextSteps: [
+          'Run: npx playwright install-deps chromium',
+          'Or: agent-browser install --with-deps',
+        ],
+      });
+    }
+  }
+
+  return { checks, issues };
+}
+
+export async function diagnoseExecutable() {
+  const issues = [];
+  const checks = {
+    agentBrowserInstalled: false,
+    agentBrowserVersion: null,
+    inPath: false,
+  };
+
+  try {
+    checks.agentBrowserVersion = execSync('agent-browser --version', { encoding: 'utf8' }).trim();
+    checks.agentBrowserInstalled = true;
+    checks.inPath = true;
+  } catch {
+    try {
+      checks.agentBrowserVersion = execSync('npx agent-browser --version', { encoding: 'utf8' }).trim();
+      checks.agentBrowserInstalled = true;
+      checks.inPath = false;
+      issues.push({
+        category: 'executable',
+        severity: 'medium',
+        message: 'agent-browser installed but not in PATH',
+        nextSteps: [
+          'Add npm global bin to PATH',
+          'Or use npx agent-browser instead of agent-browser',
+        ],
+      });
+    } catch {
+      checks.agentBrowserInstalled = false;
+      issues.push({
+        category: 'executable',
+        severity: 'critical',
+        message: 'agent-browser is not installed',
+        nextSteps: [
+          'Run: npm install -g agent-browser',
+          'Then: npx agent-browser install',
+        ],
+      });
+    }
+  }
+
+  return { checks, issues };
+}
+
+export async function diagnoseBrowser() {
+  const issues = [];
+  const checks = {
+    chromiumInstalled: false,
+    chromiumPath: null,
+  };
+
+  const homeDir = os.homedir();
+  const browserCachePath = path.join(homeDir, '.cache', 'ms-playwright');
+
+  if (fs.existsSync(browserCachePath)) {
+    try {
+      const files = fs.readdirSync(browserCachePath);
+      checks.chromiumInstalled = files.some(f => f.includes('chromium'));
+      checks.chromiumPath = browserCachePath;
+    } catch {
+      checks.chromiumInstalled = false;
+    }
+  }
+
+  if (!checks.chromiumInstalled) {
+    const agentBrowserPath = path.join(homeDir, '.agent-browser');
+    if (fs.existsSync(agentBrowserPath)) {
+      try {
+        const files = fs.readdirSync(agentBrowserPath);
+        checks.chromiumInstalled = files.some(f => f.includes('chromium') || f.includes('chrome'));
+        checks.chromiumPath = agentBrowserPath;
+      } catch {
+        checks.chromiumInstalled = false;
+      }
+    }
+  }
+
+  if (!checks.chromiumInstalled) {
+    issues.push({
+      category: 'browser',
+      severity: 'critical',
+      message: 'Chromium browser is not installed',
+      nextSteps: [
+        'Run: npx agent-browser install',
+        'Or: agent-browser install',
+      ],
+    });
+  }
+
+  return { checks, issues };
+}
+
+export async function diagnoseAuth() {
+  const issues = [];
+  const checks = {
+    hasEncryptedKey: false,
+    hasAuthCommands: false,
+  };
+
+  try {
+    execSync('agent-browser auth --help', { encoding: 'utf8', stdio: 'ignore' });
+    checks.hasAuthCommands = true;
+  } catch {
+    checks.hasAuthCommands = false;
+  }
+
+  const homeDir = os.homedir();
+  const keyPath = path.join(homeDir, '.agent-browser', '.encryption-key');
+  if (fs.existsSync(keyPath)) {
+    checks.hasEncryptedKey = true;
+  }
+
+  return { checks, issues };
+}
+
+export async function runDoctor() {
+  log('info', 'Starting doctor diagnosis...');
+  
+  const diagnosis = {
+    timestamp: new Date().toISOString(),
+    network: await diagnoseNetwork(),
+    permissions: await diagnosePermissions(),
+    dependencies: await diagnoseDependencies(),
+    systemLibraries: await diagnoseSystemLibraries(),
+    executable: await diagnoseExecutable(),
+    browser: await diagnoseBrowser(),
+    auth: await diagnoseAuth(),
+  };
+
+  const allIssues = [
+    ...diagnosis.network.issues,
+    ...diagnosis.permissions.issues,
+    ...diagnosis.dependencies.issues,
+    ...diagnosis.systemLibraries.issues,
+    ...diagnosis.executable.issues,
+    ...diagnosis.browser.issues,
+    ...diagnosis.auth.issues,
+  ];
+
+  const summary = {
+    totalIssues: allIssues.length,
+    critical: allIssues.filter(i => i.severity === 'critical').length,
+    high: allIssues.filter(i => i.severity === 'high').length,
+    medium: allIssues.filter(i => i.severity === 'medium').length,
+    categories: [...new Set(allIssues.map(i => i.category))],
+  };
+
+  const updateInfo = await checkForUpdates();
+  
+  const versionInfo = await getAgentBrowserVersion();
+
+  return {
+    ok: summary.critical === 0 && summary.high === 0,
+    summary,
+    issues: allIssues,
+    diagnosis,
+    versionInfo,
+    updateInfo,
+  };
+}
+
+export default {
+  runDoctor,
+  diagnoseNetwork,
+  diagnosePermissions,
+  diagnoseDependencies,
+  diagnoseSystemLibraries,
+  diagnoseExecutable,
+  diagnoseBrowser,
+  diagnoseAuth,
+};