fchek 1.0.0

package/lib/new_features.test.js

@@ -0,0 +1,181 @@
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+const { DatabaseSync } = require('node:sqlite');
+
+// Intercept output
+const originalConsoleLog = console.log;
+let capturedOutputs = [];
+console.log = (msg) => {
+  try {
+    capturedOutputs.push(JSON.parse(msg));
+  } catch {
+    // Fallback if not JSON
+    originalConsoleLog(msg);
+  }
+};
+
+function getLatestOutput() {
+  return capturedOutputs.pop();
+}
+
+async function runTests() {
+  console.log("=== Running fchek extensions unit tests ===");
+
+  // 1. Test Port Command
+  {
+    console.log("Testing port...");
+    const portCmd = require('./port');
+    
+    // Test port: specified but not in use
+    await portCmd.run(['9999']);
+    const out1 = getLatestOutput();
+    assert.strictEqual(out1.status, 'ok');
+    assert.strictEqual(out1.data.in_use, false);
+
+    // Test port: missing arguments
+    await portCmd.run([]);
+    const out2 = getLatestOutput();
+    assert.strictEqual(out2.status, 'error');
+  }
+
+  // 2. Test API Command
+  {
+    console.log("Testing api...");
+    const apiCmd = require('./api');
+
+    // Start a dummy HTTP server
+    const server = http.createServer((req, res) => {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ hello: 'world' }));
+    });
+    
+    await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+    const port = server.address().port;
+
+    await apiCmd.run([`http://127.0.0.1:${port}`]);
+    const out = getLatestOutput();
+    assert.strictEqual(out.status, 'ok');
+    assert.strictEqual(out.data.status_code, 200);
+    assert.ok(out.data.time_ms >= 0);
+    assert.strictEqual(JSON.parse(out.data.body).hello, 'world');
+
+    server.close();
+  }
+
+  // 3. Test DB Command
+  {
+    console.log("Testing db...");
+    const dbCmd = require('./db');
+    const dbPath = path.join(__dirname, 'test_temp.db');
+
+    // Clean up old DB
+    if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+
+    // Create a dummy SQLite DB
+    const db = new DatabaseSync(dbPath);
+    db.exec("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)");
+    db.exec("INSERT INTO users (name) VALUES ('Alice')");
+    db.close();
+
+    // Test db schema
+    await dbCmd.run(['schema', dbPath]);
+    const schemaOut = getLatestOutput();
+    assert.strictEqual(schemaOut.status, 'ok');
+    assert.strictEqual(schemaOut.data.tables[0].name, 'users');
+    assert.strictEqual(schemaOut.data.tables[0].columns[0].name, 'id');
+
+    // Test db query
+    await dbCmd.run(['query', dbPath, 'SELECT * FROM users']);
+    const queryOut = getLatestOutput();
+    assert.strictEqual(queryOut.status, 'ok');
+    assert.strictEqual(queryOut.data.rows[0].name, 'Alice');
+
+    // Clean up
+    if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+  }
+
+  // 4. Test Docker Command
+  {
+    console.log("Testing docker...");
+    const dockerCmd = require('./docker');
+    
+    // We should be able to run this gracefully (Docker might or might not be running)
+    await dockerCmd.run(['list']);
+    const listOut = getLatestOutput();
+    // Either ok or error is acceptable as long as it doesn't crash
+    assert.ok(['ok', 'error'].includes(listOut.status));
+  }
+
+  // 5. Test Vuln Command
+  {
+    console.log("Testing vuln (typosquatting)...");
+    const vulnCmd = require('./vuln');
+    const tempDir = path.join(__dirname, 'temp_vuln_project');
+    if (!fs.existsSync(tempDir)) fs.mkdirSync(tempDir);
+
+    // Write a dummy package.json with a typosquatted package name
+    // e.g. "reqeusts" instead of "requests" or "react-doom" instead of "react-dom"
+    fs.writeFileSync(path.join(tempDir, 'package.json'), JSON.stringify({
+      dependencies: {
+        'react-doom': '1.0.0', // typosquatted react-dom
+        'lodash': '4.17.21'     // correct popular package
+      }
+    }));
+
+    await vulnCmd.run([tempDir]);
+    const vulnOut = getLatestOutput();
+    assert.strictEqual(vulnOut.status, 'ok');
+    assert.ok(vulnOut.data.packages_checked >= 2);
+    
+    const warning = vulnOut.data.typosquatting_warnings.find(w => w.package === 'react-doom');
+    assert.ok(warning);
+    assert.strictEqual(warning.suspectedTyposquatOf, 'react-dom');
+
+    // Clean up
+    fs.unlinkSync(path.join(tempDir, 'package.json'));
+    fs.rmdirSync(tempDir);
+  }
+
+  // 6. Test DOM Command
+  {
+    console.log("Testing dom...");
+    const domCmd = require('./dom');
+    const tempHtml = path.join(__dirname, 'temp.html');
+    fs.writeFileSync(tempHtml, `
+      <html>
+        <body>
+          <div id="header">Welcome</div>
+          <a class="link" href="https://google.com">Link</a>
+          <p>Text</p>
+        </body>
+      </html>
+    `);
+
+    // Test selector ID
+    await domCmd.run([tempHtml, '#header']);
+    const outId = getLatestOutput();
+    assert.strictEqual(outId.status, 'ok');
+    assert.strictEqual(outId.data.matches[0].text, 'Welcome');
+
+    // Test selector class
+    await domCmd.run([tempHtml, '.link', '--attr=href']);
+    const outClass = getLatestOutput();
+    assert.strictEqual(outClass.status, 'ok');
+    assert.strictEqual(outClass.data.matches[0].attribute_value, 'https://google.com');
+
+    // Clean up
+    if (fs.existsSync(tempHtml)) fs.unlinkSync(tempHtml);
+  }
+
+  console.log("All unit tests passed successfully!");
+}
+
+runTests().catch(err => {
+  originalConsoleLog("\nTest failed with error:");
+  originalConsoleLog(err);
+  process.exit(1);
+});

package/lib/output.js

@@ -0,0 +1,46 @@
+'use strict';
+
+/**
+ * output.js — unified JSON output helper for all fchek commands.
+ *
+ * Every command outputs exactly one JSON object to stdout:
+ * {
+ *   "status": "ok" | "error",
+ *   "command": "<name>",
+ *   "data": { ... }   // present when status === "ok"
+ *   "error": "..."    // present when status === "error"
+ * }
+ *
+ * AI agents should parse stdout as JSON.
+ * Human-readable text mode is available with --text flag (checked globally).
+ */
+
+const TEXT_MODE = process.argv.includes('--text');
+
+function ok(data, command) {
+  return { status: 'ok', command: command || detectCommand(), data };
+}
+
+function fail(errorMsg, command) {
+  return { status: 'error', command: command || detectCommand(), error: errorMsg };
+}
+
+function output(result) {
+  if (TEXT_MODE) {
+    // Human-readable fallback
+    if (result.status === 'error') {
+      console.error(`\n[fchek error] ${result.error}\n`);
+    } else {
+      console.log('\n' + JSON.stringify(result.data, null, 2) + '\n');
+    }
+  } else {
+    console.log(JSON.stringify(result));
+  }
+}
+
+function detectCommand() {
+  const args = process.argv.slice(2);
+  return args[0] || 'unknown';
+}
+
+module.exports = { ok, fail, output, TEXT_MODE };

package/lib/port.js

@@ -0,0 +1,173 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const os = require('os');
+const { output, ok, fail } = require('./output');
+
+const HELP = `
+fchek port <port> [--all]
+
+Inspects network ports and active connections.
+If <port> is specified, returns information about the process using that port.
+If --all is specified, returns a list of all active listening ports.
+`.trim();
+
+function getProcessName(pid) {
+  if (!pid || pid === '-' || pid === '0') return 'System/Unknown';
+  try {
+    if (os.platform() === 'win32') {
+      const out = execSync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+      // "image_name","pid","session_name","session_num","mem_usage"
+      const parts = out.trim().split(',');
+      if (parts.length > 0) {
+        return parts[0].replace(/"/g, '');
+      }
+    } else {
+      const out = execSync(`ps -p ${pid} -o comm=`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+      return out.trim();
+    }
+  } catch (err) {
+    // ignore
+  }
+  return 'Unknown';
+}
+
+function getPortInfoWindows(targetPort) {
+  try {
+    const out = execSync('netstat -ano', { encoding: 'utf8' });
+    const lines = out.split('\n');
+    const results = [];
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith('TCP') && !trimmed.startsWith('UDP')) continue;
+      
+      // Proto  Local Address          Foreign Address        State           PID
+      // TCP    0.0.0.0:80             0.0.0.0:0              LISTENING       4
+      const parts = trimmed.split(/\s+/);
+      if (parts.length < 4) continue;
+
+      const proto = parts[0];
+      const localAddress = parts[1];
+      const state = proto === 'TCP' ? parts[3] : 'UDP';
+      const pidStr = proto === 'TCP' ? parts[4] : parts[3];
+      const pid = parseInt(pidStr, 10);
+
+      // Extract port from local address (e.g. 0.0.0.0:80 or [::]:80)
+      const lastColon = localAddress.lastIndexOf(':');
+      if (lastColon === -1) continue;
+      const port = parseInt(localAddress.slice(lastColon + 1), 10);
+
+      if (targetPort && port !== targetPort) continue;
+
+      results.push({
+        proto,
+        localAddress,
+        state,
+        port,
+        pid,
+      });
+    }
+
+    // De-duplicate and add process names
+    const seen = new Set();
+    const uniqueResults = [];
+    for (const r of results) {
+      const key = `${r.proto}-${r.port}-${r.pid}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      r.processName = getProcessName(r.pid);
+      uniqueResults.push(r);
+    }
+
+    return uniqueResults;
+  } catch (err) {
+    throw new Error(`Failed to run netstat: ${err.message}`);
+  }
+}
+
+function getPortInfoUnix(targetPort) {
+  try {
+    // Use lsof -i :port or ss -tulnp / netstat
+    let out = '';
+    if (targetPort) {
+      try {
+        out = execSync(`lsof -i :${targetPort} -sTCP:LISTEN -t`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+        const pids = out.trim().split('\n').filter(Boolean);
+        return pids.map(pidStr => {
+          const pid = parseInt(pidStr, 10);
+          return {
+            proto: 'TCP',
+            localAddress: `*:${targetPort}`,
+            state: 'LISTEN',
+            port: targetPort,
+            pid,
+            processName: getProcessName(pid),
+          };
+        });
+      } catch {
+        return [];
+      }
+    } else {
+      // Return list using ss -tuln
+      try {
+        out = execSync('ss -tuln', { encoding: 'utf8' });
+      } catch {
+        out = execSync('netstat -tuln', { encoding: 'utf8' });
+      }
+      // Parse output...
+      const results = [];
+      const lines = out.split('\n');
+      for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        // Simple heuristic to extract ports
+        for (const part of parts) {
+          const match = part.match(/:(\d+)$/);
+          if (match) {
+            const port = parseInt(match[1], 10);
+            results.push({ proto: 'TCP', port, state: 'LISTEN' });
+          }
+        }
+      }
+      return results;
+    }
+  } catch (err) {
+    throw new Error(`Failed to list ports: ${err.message}`);
+  }
+}
+
+async function run(args) {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(HELP);
+    return;
+  }
+
+  const isAll = args.includes('--all');
+  const targetPortStr = args.find(a => !a.startsWith('-'));
+  const targetPort = targetPortStr ? parseInt(targetPortStr, 10) : null;
+
+  if (!targetPort && !isAll) {
+    output(fail('Please specify a port number (e.g. fchek port 8080) or use --all', 'port'));
+    return;
+  }
+
+  const platform = os.platform();
+  let data;
+  if (platform === 'win32') {
+    data = getPortInfoWindows(targetPort);
+  } else {
+    data = getPortInfoUnix(targetPort);
+  }
+
+  if (targetPort && data.length === 0) {
+    output(ok({ port: targetPort, in_use: false, connections: [] }, 'port'));
+  } else {
+    output(ok({
+      port: targetPort || 'all',
+      in_use: data.length > 0,
+      connections: data,
+    }, 'port'));
+  }
+}
+
+module.exports = { run };

package/lib/process.js

@@ -0,0 +1,228 @@
+'use strict';
+
+/**
+ * process.js — list, inspect, kill Windows processes
+ *
+ * Agent uses this to:
+ * - Check if app is running before launching
+ * - Monitor memory/CPU after launch
+ * - Kill stuck instances
+ * - Detect crashes (process disappeared)
+ */
+
+const { spawnSync } = require('child_process');
+const { output, ok, fail } = require('./output');
+
+const HELP = `
+fchek process <action> [args...]
+
+List, monitor, and manage Windows processes.
+
+Actions:
+  list [--filter=<name>]         List running processes (optional filter)
+  info <name_or_pid>             Detailed info: memory, cpu, threads, start time
+  kill <name_or_pid>             Kill a process by name or PID
+  exists <name>                  Check if process is running (returns bool)
+  wait-exit <name> [--timeout=ms] Wait until process exits
+
+Examples:
+  fchek process list
+  fchek process list --filter=Vertex
+  fchek process info Vertex
+  fchek process info 1234
+  fchek process kill Vertex
+  fchek process exists Vertex
+  fchek process wait-exit Vertex --timeout=10000
+`.trim();
+
+function runPowerShell(script, timeoutMs = 15000) {
+  return spawnSync('powershell', [
+    '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script,
+  ], { encoding: 'utf8', timeout: timeoutMs, windowsHide: true });
+}
+
+async function run(args) {
+  if (args.length === 0 || args[0] === '--help') { console.log(HELP); return; }
+
+  if (process.platform !== 'win32') {
+    return output(fail('fchek process is Windows-only.'));
+  }
+
+  const action = args[0];
+
+  switch (action) {
+    case 'list': {
+      const filter = (args.find(a => a.startsWith('--filter=')) || '').replace('--filter=', '') || null;
+
+      const filterClause = filter
+        ? `| Where-Object { $_.ProcessName -match ${JSON.stringify(filter)} -or $_.MainWindowTitle -match ${JSON.stringify(filter)} }`
+        : '';
+
+      const script = `
+$procs = Get-Process ${filterClause} -ErrorAction SilentlyContinue |
+    Where-Object { $_.Id -ne $PID } |
+    Select-Object -First 100 |
+    ForEach-Object {
+        @{
+            pid       = $_.Id
+            name      = $_.ProcessName
+            title     = $_.MainWindowTitle
+            has_window = ($_.MainWindowHandle -ne [IntPtr]::Zero)
+            mem_mb    = [Math]::Round($_.WorkingSet64 / 1MB, 1)
+            cpu_s     = [Math]::Round($_.TotalProcessorTime.TotalSeconds, 2)
+            threads   = $_.Threads.Count
+            started   = if ($_.StartTime) { $_.StartTime.ToString("HH:mm:ss") } else { "?" }
+        }
+    }
+$json = $procs | ConvertTo-Json -Depth 3 -Compress
+if ($null -eq $json) { $json = "[]" }
+Write-Output $json
+`;
+
+      const res = runPowerShell(script);
+      const raw = (res.stdout || '').trim();
+      let procs = [];
+      try {
+        const parsed = JSON.parse(raw || '[]');
+        procs = Array.isArray(parsed) ? parsed : [parsed];
+      } catch { return output(fail(`Parse error: ${raw.slice(0, 300)}`)); }
+
+      output(ok({ filter, count: procs.length, processes: procs }));
+      break;
+    }
+
+    case 'info': {
+      const target = args[1];
+      if (!target) return output(fail('Usage: fchek process info <name_or_pid>'));
+
+      const isPid = /^\d+$/.test(target);
+      const selector = isPid ? `-Id ${target}` : `-Name "${target}"`;
+
+      const script = `
+$ErrorActionPreference = 'SilentlyContinue'
+$proc = Get-Process ${selector} | Select-Object -First 1
+if ($null -eq $proc) {
+    Write-Output '{"found":false}'
+} else {
+    $modules = @()
+    try { $modules = $proc.Modules | ForEach-Object { $_.ModuleName } | Select-Object -First 20 } catch {}
+    @{
+        found        = $true
+        pid          = $proc.Id
+        name         = $proc.ProcessName
+        title        = $proc.MainWindowTitle
+        has_window   = ($proc.MainWindowHandle -ne [IntPtr]::Zero)
+        mem_mb       = [Math]::Round($proc.WorkingSet64 / 1MB, 1)
+        peak_mem_mb  = [Math]::Round($proc.PeakWorkingSet64 / 1MB, 1)
+        cpu_s        = [Math]::Round($proc.TotalProcessorTime.TotalSeconds, 2)
+        threads      = $proc.Threads.Count
+        handles      = $proc.HandleCount
+        started      = if ($proc.StartTime) { $proc.StartTime.ToString("yyyy-MM-dd HH:mm:ss") } else { "?" }
+        exe_path     = $proc.MainModule.FileName
+        modules_count = $proc.Modules.Count
+    } | ConvertTo-Json -Compress
+}
+`;
+
+      const res = runPowerShell(script);
+      const raw = (res.stdout || '').trim();
+      let data;
+      try { data = JSON.parse(raw); } catch { return output(fail(`Parse error: ${raw.slice(0, 300)}`)); }
+      if (!data.found) return output(fail(`Process not found: ${target}`));
+      output(ok(data));
+      break;
+    }
+
+    case 'kill': {
+      const target = args[1];
+      if (!target) return output(fail('Usage: fchek process kill <name_or_pid>'));
+
+      const isPid    = /^\d+$/.test(target);
+      const selector = isPid ? `-Id ${target}` : `-Name "${target}"`;
+
+      const script = `
+$ErrorActionPreference = 'SilentlyContinue'
+$procs = Get-Process ${selector} -ErrorAction SilentlyContinue
+if ($null -eq $procs -or $procs.Count -eq 0) {
+    Write-Output ('{"killed":false,"error":"Process not found: ${target}"}')
+} else {
+    $killed = @()
+    foreach ($p in $procs) {
+        try {
+            $pid = $p.Id
+            $name = $p.ProcessName
+            $p.Kill()
+            $killed += @{ pid = $pid; name = $name }
+        } catch {}
+    }
+    $json = $killed | ConvertTo-Json -Compress
+    if ($null -eq $json) { $json = "[]" }
+    Write-Output ('{"killed":true,"processes":' + $json + '}')
+}
+`;
+
+      const res = runPowerShell(script);
+      const raw = (res.stdout || '').trim();
+      let data;
+      try { data = JSON.parse(raw); } catch { return output(fail(`Parse error: ${raw.slice(0, 300)}`)); }
+      if (!data.killed) return output(fail(data.error));
+      output(ok(data));
+      break;
+    }
+
+    case 'exists': {
+      const name = args[1];
+      if (!name) return output(fail('Usage: fchek process exists <name>'));
+
+      const script = `
+$proc = Get-Process -Name "${name}" -ErrorAction SilentlyContinue | Select-Object -First 1
+if ($null -eq $proc) {
+    Write-Output '{"exists":false}'
+} else {
+    Write-Output ('{"exists":true,"pid":' + $proc.Id + ',"name":"' + $proc.ProcessName + '","mem_mb":' + [Math]::Round($proc.WorkingSet64/1MB,1) + '}')
+}
+`;
+
+      const res = runPowerShell(script);
+      const raw = (res.stdout || '').trim();
+      let data;
+      try { data = JSON.parse(raw); } catch { return output(fail(`Parse error: ${raw.slice(0, 300)}`)); }
+      output(ok(data));
+      break;
+    }
+
+    case 'wait-exit': {
+      const name    = args[1];
+      const timeout = parseInt((args.find(a => a.startsWith('--timeout=')) || '--timeout=30000').replace('--timeout=', ''), 10);
+      if (!name) return output(fail('Usage: fchek process wait-exit <name> [--timeout=30000]'));
+
+      const script = `
+$step = 500
+$elapsed = 0
+$timeout = ${timeout}
+while ($elapsed -lt $timeout) {
+    $proc = Get-Process -Name "${name}" -ErrorAction SilentlyContinue
+    if ($null -eq $proc) {
+        Write-Output ('{"exited":true,"elapsed_ms":' + $elapsed + '}')
+        exit 0
+    }
+    Start-Sleep -Milliseconds $step
+    $elapsed += $step
+}
+Write-Output ('{"exited":false,"elapsed_ms":' + $elapsed + ',"error":"Process still running after ' + $timeout + 'ms"}')
+`;
+
+      const res = runPowerShell(script, timeout + 5000);
+      const raw = (res.stdout || '').trim();
+      let data;
+      try { data = JSON.parse(raw); } catch { return output(fail(`Parse error: ${raw.slice(0, 300)}`)); }
+      output(ok({ name, ...data }));
+      break;
+    }
+
+    default:
+      output(fail(`Unknown action: "${action}". Valid: list, info, kill, exists, wait-exit`));
+  }
+}
+
+module.exports = { run };