fchek 1.0.0

package/lib/run.js

@@ -0,0 +1,403 @@
+'use strict';
+
+/**
+ * run.js — execute code and return stdout/stderr/exit in JSON
+ *
+ * MANDATORY before claiming code "works".
+ * Works on Windows, Linux, macOS — detects available compilers/runtimes.
+ */
+
+const { spawnSync, execSync } = require('child_process');
+const path   = require('path');
+const fs     = require('fs');
+const os     = require('os');
+const { output, ok, fail } = require('./output');
+
+const HELP = `
+fchek run <file> [args...] [--timeout=30000] [--stdin=<text>] [--no-color]
+
+Execute code and return stdout, stderr, exit code in JSON.
+MANDATORY before claiming code "works". No guessing — only real output.
+
+Auto-detects runtime by extension:
+  .py         → python3 / python
+  .js / .mjs  → node
+  .ts         → ts-node (falls back to tsc + node)
+  .rs         → cargo run (Cargo project) or rustc + run
+  .c / .cpp   → gcc/g++ (Linux/macOS) or MinGW/cl (Windows)
+  .go         → go run
+  .sh         → bash (Linux/macOS) or WSL bash (Windows)
+  .rb         → ruby
+  .php        → php
+
+Options:
+  --timeout=30000   Max run time in ms (default: 30000)
+  --stdin=<text>    Pass text as stdin
+  --no-color        Strip ANSI codes from output
+
+Examples:
+  fchek run main.py
+  fchek run main.cpp
+  fchek run app.ts --timeout=10000
+  fchek run script.sh --stdin="hello"
+`.trim();
+
+const DEFAULT_TIMEOUT = 30_000;
+
+// ─── Platform helpers ─────────────────────────────────────────────────────────
+
+const IS_WIN = process.platform === 'win32';
+
+function commandExists(cmd) {
+  try {
+    execSync(IS_WIN ? `where ${cmd}` : `which ${cmd}`, { stdio: 'ignore', timeout: 3000 });
+    return true;
+  } catch { return false; }
+}
+
+/** Find a C/C++ compiler that actually exists on this machine */
+function findCCompiler(isCpp) {
+  if (isCpp) {
+    const candidates = IS_WIN
+      ? ['g++', 'clang++', 'c++']
+      : ['g++', 'clang++', 'c++'];
+    for (const c of candidates) {
+      if (commandExists(c)) return c;
+    }
+    return null;
+  } else {
+    const candidates = IS_WIN
+      ? ['gcc', 'clang', 'cc']
+      : ['gcc', 'clang', 'cc'];
+    for (const c of candidates) {
+      if (commandExists(c)) return c;
+    }
+    return null;
+  }
+}
+
+function findPython() {
+  // Delegate to shared python helper which handles Windows Store alias correctly
+  return require('./python').findPython();
+}
+
+function stripAnsi(str) {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+// ─── Result builder ───────────────────────────────────────────────────────────
+
+function buildResult(file, lang, spawnResult, timeoutMs, extra = {}) {
+  const timedOut = spawnResult.error?.code === 'ETIMEDOUT';
+  const notFound = spawnResult.error?.code === 'ENOENT';
+  const stdout   = (spawnResult.stdout || '').slice(0, 50000);
+  const stderr   = (spawnResult.stderr || '').slice(0, 10000);
+  const exitCode = timedOut || notFound ? null : spawnResult.status;
+
+  let errorMsg = null;
+  if (timedOut) {
+    errorMsg = `Timed out after ${timeoutMs}ms — possible infinite loop or blocking I/O`;
+  } else if (notFound) {
+    errorMsg = `Runtime not found: ${extra.runner || '?'}. Run: fchek doctor`;
+  } else if (spawnResult.error) {
+    errorMsg = spawnResult.error.message;
+  }
+
+  return {
+    file:          path.resolve(file),
+    lang,
+    exit_code:     exitCode,
+    success:       !timedOut && !notFound && spawnResult.status === 0,
+    timed_out:     timedOut,
+    stdout,
+    stderr,
+    stdout_lines:  stdout.split('\n').filter(Boolean).length,
+    error:         errorMsg,
+    ...extra,
+  };
+}
+
+// ─── C / C++ ──────────────────────────────────────────────────────────────────
+
+function compileAndRunC(file, extraArgs, timeoutMs, stdinText) {
+  const ext      = path.extname(file).toLowerCase();
+  const isCpp    = ext === '.cpp' || ext === '.cc';
+  const compiler = findCCompiler(isCpp);
+
+  if (!compiler) {
+    const hint = IS_WIN
+      ? 'Install MinGW: https://winlibs.com  OR  use WSL'
+      : `Install: ${isCpp ? 'apt install g++' : 'apt install gcc'}`;
+    return output(fail(
+      `No C${isCpp ? '++' : ''} compiler found on this system.\n${hint}`
+    ));
+  }
+
+  const outBin = path.join(
+    os.tmpdir(),
+    `fchek_run_${path.basename(file, ext)}_${Date.now()}${IS_WIN ? '.exe' : ''}`
+  );
+
+  const compileArgs = isCpp
+    ? ['-std=c++17', '-o', outBin, file]
+    : ['-o', outBin, file];
+
+  const compile = spawnSync(compiler, compileArgs, { encoding: 'utf8', timeout: 30000 });
+
+  if (compile.status !== 0 || compile.error) {
+    return output(ok({
+      file:      path.resolve(file),
+      lang:      isCpp ? 'cpp' : 'c',
+      compiler,
+      compiled:  false,
+      exit_code: compile.status,
+      success:   false,
+      stdout:    '',
+      stderr:    (compile.stderr || compile.error?.message || 'Compilation failed').slice(0, 5000),
+      error:     'Compilation failed — see stderr',
+    }));
+  }
+
+  const run = spawnSync(outBin, extraArgs, {
+    encoding: 'utf8',
+    timeout:  timeoutMs,
+    input:    stdinText || undefined,
+  });
+
+  try { fs.unlinkSync(outBin); } catch {}
+
+  output(ok({
+    ...buildResult(file, isCpp ? 'cpp' : 'c', run, timeoutMs, { compiler, runner: outBin }),
+    compiled: true,
+  }));
+}
+
+// ─── Rust ─────────────────────────────────────────────────────────────────────
+
+function runRust(file, extraArgs, timeoutMs, stdinText) {
+  if (!commandExists('cargo') && !commandExists('rustc')) {
+    return output(fail(
+      'Rust not found. Install: https://rustup.rs\n' +
+      'Then: rustup default stable'
+    ));
+  }
+
+  // Walk up to find Cargo.toml
+  let dir = path.dirname(path.resolve(file));
+  for (let i = 0; i < 6; i++) {
+    if (fs.existsSync(path.join(dir, 'Cargo.toml')) && commandExists('cargo')) {
+      const res = spawnSync('cargo', ['run', '--', ...extraArgs], {
+        encoding: 'utf8',
+        cwd:      dir,
+        timeout:  timeoutMs,
+        input:    stdinText || undefined,
+      });
+      return output(ok(buildResult(file, 'rust', res, timeoutMs, { tool: 'cargo run', cwd: dir })));
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  // Single file with rustc
+  if (!commandExists('rustc')) {
+    return output(fail('rustc not found. Install: https://rustup.rs'));
+  }
+
+  const outBin = path.join(
+    os.tmpdir(),
+    `fchek_run_${path.basename(file, '.rs')}_${Date.now()}${IS_WIN ? '.exe' : ''}`
+  );
+  const compile = spawnSync('rustc', [file, '-o', outBin], { encoding: 'utf8', timeout: 30000 });
+  if (compile.status !== 0) {
+    return output(ok({
+      file: path.resolve(file), lang: 'rust', compiled: false,
+      exit_code: compile.status, success: false, stdout: '',
+      stderr: (compile.stderr || '').slice(0, 5000), error: 'Compilation failed',
+    }));
+  }
+
+  const run = spawnSync(outBin, extraArgs, {
+    encoding: 'utf8', timeout: timeoutMs, input: stdinText || undefined,
+  });
+  try { fs.unlinkSync(outBin); } catch {}
+  output(ok({ ...buildResult(file, 'rust', run, timeoutMs, { tool: 'rustc', runner: outBin }), compiled: true }));
+}
+
+// ─── TypeScript ───────────────────────────────────────────────────────────────
+
+function runTypeScript(file, extraArgs, timeoutMs, stdinText) {
+  // Try ts-node first
+  if (commandExists('ts-node')) {
+    const res = spawnSync('ts-node', [file, ...extraArgs], {
+      encoding: 'utf8', timeout: timeoutMs, input: stdinText || undefined,
+    });
+    return output(ok(buildResult(file, 'typescript', res, timeoutMs, { runner: 'ts-node' })));
+  }
+
+  // Try npx ts-node
+  if (commandExists('npx')) {
+    const res = spawnSync('npx', ['ts-node', file, ...extraArgs], {
+      encoding: 'utf8', timeout: timeoutMs, input: stdinText || undefined,
+    });
+    if (!res.error) {
+      return output(ok(buildResult(file, 'typescript', res, timeoutMs, { runner: 'npx ts-node' })));
+    }
+  }
+
+  return output(fail(
+    'ts-node not found. Install: npm install -g ts-node typescript\n' +
+    'Or run: npx ts-node ' + file
+  ));
+}
+
+// ─── Shell ────────────────────────────────────────────────────────────────────
+
+function runShell(file, extraArgs, timeoutMs, stdinText) {
+  if (IS_WIN) {
+    // Try WSL bash, then Git bash
+    for (const bash of ['wsl', 'bash']) {
+      if (commandExists(bash)) {
+        const wslArgs = bash === 'wsl' ? ['bash', file, ...extraArgs] : [file, ...extraArgs];
+        const res = spawnSync(bash, wslArgs, {
+          encoding: 'utf8', timeout: timeoutMs, input: stdinText || undefined,
+        });
+        return output(ok(buildResult(file, 'shell', res, timeoutMs, { runner: bash })));
+      }
+    }
+    return output(fail(
+      'No bash found on Windows.\n' +
+      'Install WSL: wsl --install\n' +
+      'Or install Git for Windows (includes bash): https://git-scm.com'
+    ));
+  }
+
+  const bash = commandExists('bash') ? 'bash' : 'sh';
+  const res  = spawnSync(bash, [file, ...extraArgs], {
+    encoding: 'utf8', timeout: timeoutMs, input: stdinText || undefined,
+  });
+  return output(ok(buildResult(file, 'shell', res, timeoutMs, { runner: bash })));
+}
+
+// ─── Generic runner ───────────────────────────────────────────────────────────
+
+function runGeneric(file, runner, lang, extraArgs, timeoutMs, stdinText) {
+  if (!commandExists(runner)) {
+    return output(fail(
+      `${runner} not found. Run: fchek doctor  to see what's missing.`
+    ));
+  }
+  const res = spawnSync(runner, [file, ...extraArgs], {
+    encoding: 'utf8', timeout: timeoutMs, input: stdinText || undefined,
+  });
+  return output(ok(buildResult(file, lang, res, timeoutMs, { runner })));
+}
+
+// ─── Entry point ─────────────────────────────────────────────────────────────
+
+async function run(args) {
+  if (args.length === 0 || args[0] === '--help') { console.log(HELP); return; }
+
+  const file       = args[0];
+  const flagArgs   = args.slice(1);
+  const extraArgs  = flagArgs.filter(a =>
+    !a.startsWith('--timeout=') && !a.startsWith('--stdin=') && a !== '--no-color'
+  );
+  const timeoutMs  = parseInt(
+    (flagArgs.find(a => a.startsWith('--timeout=')) || `--timeout=${DEFAULT_TIMEOUT}`)
+      .replace('--timeout=', ''), 10
+  );
+  const stdinText  = (flagArgs.find(a => a.startsWith('--stdin=')) || '').replace('--stdin=', '') || null;
+  const noColor    = flagArgs.includes('--no-color');
+
+  if (!fs.existsSync(file)) {
+    return output(fail(`File not found: ${file}`));
+  }
+
+  const ext = path.extname(file).toLowerCase();
+
+  let result;
+
+  if (['.c', '.cpp', '.cc'].includes(ext)) {
+    return compileAndRunC(file, extraArgs, timeoutMs, stdinText);
+  }
+  if (ext === '.rs') {
+    return runRust(file, extraArgs, timeoutMs, stdinText);
+  }
+  if (ext === '.ts' || ext === '.tsx') {
+    return runTypeScript(file, extraArgs, timeoutMs, stdinText);
+  }
+  if (ext === '.sh' || ext === '.bash') {
+    return runShell(file, extraArgs, timeoutMs, stdinText);
+  }
+  if (ext === '.py') {
+    const py = findPython();
+    if (!py) return output(fail('Python not found. Install: https://python.org'));
+    const res = spawnSync(py, [file, ...extraArgs], {
+      encoding: 'utf8', timeout: timeoutMs, input: stdinText || undefined,
+      windowsHide: true,
+    });
+    result = buildResult(file, 'python', res, timeoutMs, { runner: py });
+  } else if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {
+    if (!commandExists('node')) {
+      return output(fail('node not found. Install: https://nodejs.org'));
+    }
+    const res = spawnSync('node', [file, ...extraArgs], {
+      encoding: 'utf8', timeout: timeoutMs, input: stdinText || undefined,
+    });
+    result = buildResult(file, 'javascript', res, timeoutMs, { runner: 'node' });
+  } else if (ext === '.go') {
+    if (!commandExists('go')) {
+      return output(fail('go not found. Install: https://go.dev'));
+    }
+    const res = spawnSync('go', ['run', file, ...extraArgs], {
+      encoding: 'utf8', timeout: timeoutMs, input: stdinText || undefined,
+    });
+    result = buildResult(file, 'go', res, timeoutMs, { runner: 'go run' });
+  } else if (ext === '.cs') {
+    // C# — needs a .csproj. Walk up to find it, then use dotnet run
+    let projDir = path.dirname(path.resolve(file));
+    let csproj = null;
+    for (let i = 0; i < 6; i++) {
+      const found = fs.readdirSync(projDir).find(f => f.endsWith('.csproj') || f.endsWith('.sln'));
+      if (found) { csproj = projDir; break; }
+      const parent = path.dirname(projDir);
+      if (parent === projDir) break;
+      projDir = parent;
+    }
+    if (!commandExists('dotnet')) {
+      return output(fail(
+        'dotnet not found. Install .NET SDK: https://dotnet.microsoft.com/download'
+      ));
+    }
+    if (!csproj) {
+      return output(fail(
+        'No .csproj or .sln found in parent directories.\n' +
+        'Create a project first: dotnet new console -o MyApp'
+      ));
+    }
+    const res = spawnSync('dotnet', ['run', '--project', csproj, '--', ...extraArgs], {
+      encoding: 'utf8', timeout: timeoutMs, input: stdinText || undefined,
+    });
+    result = buildResult(file, 'csharp', res, timeoutMs, { runner: 'dotnet run', cwd: csproj });
+  } else if (ext === '.rb') {
+    return runGeneric(file, 'ruby', 'ruby', extraArgs, timeoutMs, stdinText);
+  } else if (ext === '.php') {
+    return runGeneric(file, 'php', 'php', extraArgs, timeoutMs, stdinText);
+  } else {
+    return output(fail(
+      `No runner for extension: ${ext}\n` +
+      `Supported: .py .js .ts .rs .c .cpp .go .cs .sh .rb .php`
+    ));
+  }
+
+  if (noColor) {
+    result.stdout = stripAnsi(result.stdout);
+    result.stderr = stripAnsi(result.stderr);
+  }
+
+  output(ok(result));
+}
+
+module.exports = { run };

package/lib/screenshot.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs   = require('fs');
+const os   = require('os');
+const { output, ok, fail } = require('./output');
+
+const HELP = `
+fchek screenshot [--window=<title>] [--screen] [--out=<path>] [--region=x,y,w,h]
+
+Capture a screenshot of a window or the full screen. Returns PNG file path in JSON.
+
+Examples:
+  fchek screenshot --screen
+  fchek screenshot --window=Vertex
+  fchek screenshot --region=0,0,800,600
+`.trim();
+
+function runPs(lines, timeoutMs) {
+  const script = lines.join('\r\n');
+  const tmp = path.join(os.tmpdir(), 'fchek_shot_' + process.pid + '.ps1');
+  fs.writeFileSync(tmp, script, 'utf8');
+  const res = spawnSync('powershell', [
+    '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', tmp,
+  ], { encoding: 'utf8', timeout: timeoutMs || 20000, windowsHide: true });
+  try { fs.unlinkSync(tmp); } catch {}
+  return res;
+}
+
+function parseResult(res) {
+  const raw = (res.stdout || '').trim();
+  const lines = raw.split('\n').map(l => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].startsWith('{')) {
+      try { return JSON.parse(lines[i]); } catch {}
+    }
+  }
+  return null;
+}
+
+async function run(args) {
+  if (args[0] === '--help') { console.log(HELP); return; }
+  if (process.platform !== 'win32') return output(fail('fchek screenshot is Windows-only.'));
+
+  const windowTitle = (args.find(a => a.startsWith('--window=')) || '').replace('--window=', '') || null;
+  const outArg      = (args.find(a => a.startsWith('--out='))    || '').replace('--out=',    '') || null;
+  const regionArg   = (args.find(a => a.startsWith('--region=')) || '').replace('--region=', '') || null;
+
+  const outFile  = outArg || path.join(os.tmpdir(), 'fchek_screenshot_' + Date.now() + '.png');
+  const safeOut  = outFile.replace(/"/g, '`"');
+
+  let lines;
+
+  const winApiLines = [
+    'Add-Type -AssemblyName System.Windows.Forms',
+    'Add-Type -AssemblyName System.Drawing',
+    'Add-Type @"',
+    'using System;',
+    'using System.Runtime.InteropServices;',
+    'using System.Drawing;',
+    'public class WC {',
+    '    [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr h, out RECT r);',
+    '    [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr h);',
+    '    [DllImport("user32.dll")] public static extern bool ShowWindow(IntPtr h, int c);',
+    '    public struct RECT { public int Left, Top, Right, Bottom; }',
+    '}',
+    '"@',
+  ];
+
+  if (windowTitle) {
+    const safeTitle = windowTitle.replace(/"/g, '`"');
+    lines = [
+      ...winApiLines,
+      '$outFile = "' + safeOut + '"',
+      '$title = "' + safeTitle + '"',
+      '$procs = Get-Process | Where-Object { $_.MainWindowTitle -match [regex]::Escape($title) -and $_.MainWindowHandle -ne [IntPtr]::Zero }',
+      'if ($procs.Count -eq 0) {',
+      '    Write-Output (@{found=$false; error="Window not found: $title"} | ConvertTo-Json -Compress)',
+      '    exit',
+      '}',
+      '$proc = $procs[0]',
+      '[WC]::ShowWindow($proc.MainWindowHandle, 9) | Out-Null',
+      '[WC]::SetForegroundWindow($proc.MainWindowHandle) | Out-Null',
+      'Start-Sleep -Milliseconds 400',
+      '$r = New-Object WC+RECT',
+      '[WC]::GetWindowRect($proc.MainWindowHandle, [ref]$r) | Out-Null',
+      '$w = $r.Right - $r.Left',
+      '$h = $r.Bottom - $r.Top',
+      'if ($w -le 0 -or $h -le 0) {',
+      '    Write-Output (@{found=$true; error="Window has zero size (minimized?)"} | ConvertTo-Json -Compress)',
+      '    exit',
+      '}',
+      '$bmp = New-Object System.Drawing.Bitmap($w, $h)',
+      '$g = [System.Drawing.Graphics]::FromImage($bmp)',
+      '$g.CopyFromScreen($r.Left, $r.Top, 0, 0, [System.Drawing.Size]::new($w, $h))',
+      '$bmp.Save($outFile)',
+      '$g.Dispose(); $bmp.Dispose()',
+      '$wt = $proc.MainWindowTitle',
+      'Write-Output (@{found=$true; window=$wt; pid=$proc.Id; x=$r.Left; y=$r.Top; width=$w; height=$h; file=$outFile} | ConvertTo-Json -Compress)',
+    ];
+
+  } else if (regionArg) {
+    const [rx, ry, rw, rh] = regionArg.split(',').map(Number);
+    lines = [
+      'Add-Type -AssemblyName System.Drawing',
+      '$outFile = "' + safeOut + '"',
+      '$bmp = New-Object System.Drawing.Bitmap(' + rw + ', ' + rh + ')',
+      '$g = [System.Drawing.Graphics]::FromImage($bmp)',
+      '$g.CopyFromScreen(' + rx + ', ' + ry + ', 0, 0, [System.Drawing.Size]::new(' + rw + ', ' + rh + '))',
+      '$bmp.Save($outFile)',
+      '$g.Dispose(); $bmp.Dispose()',
+      'Write-Output (@{file=$outFile; width=' + rw + '; height=' + rh + '; type="region"} | ConvertTo-Json -Compress)',
+    ];
+
+  } else {
+    lines = [
+      'Add-Type -AssemblyName System.Windows.Forms',
+      'Add-Type -AssemblyName System.Drawing',
+      '$outFile = "' + safeOut + '"',
+      '$s = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds',
+      '$bmp = New-Object System.Drawing.Bitmap($s.Width, $s.Height)',
+      '$g = [System.Drawing.Graphics]::FromImage($bmp)',
+      '$g.CopyFromScreen($s.Location, [System.Drawing.Point]::Empty, $s.Size)',
+      '$bmp.Save($outFile)',
+      '$g.Dispose(); $bmp.Dispose()',
+      'Write-Output (@{file=$outFile; width=$s.Width; height=$s.Height; type="fullscreen"} | ConvertTo-Json -Compress)',
+    ];
+  }
+
+  const res  = runPs(lines);
+  const data = parseResult(res);
+
+  if (!data) {
+    return output(fail('Screenshot failed: ' + (res.stderr || res.stdout || 'no output').slice(0, 400)));
+  }
+  if (data.error) return output(fail(data.error));
+  if (!fs.existsSync(outFile)) return output(fail('Screenshot file not created.'));
+
+  const stat = fs.statSync(outFile);
+  output(ok({
+    file:    outFile,
+    size_kb: Math.round(stat.size / 1024),
+    width:   data.width,
+    height:  data.height,
+    window:  data.window || null,
+    pid:     data.pid    || null,
+    type:    windowTitle ? 'window' : regionArg ? 'region' : 'fullscreen',
+  }));
+}
+
+module.exports = { run };