claws-code 0.8.0

package/lib/mcp-setup.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { dryRunLog } = require('./platform.js');
+
+// Strip JSONC extensions (line/block comments, trailing commas) from text before
+// JSON.parse. Handles .mcp.json files with VS Code JSONC comments.
+// Matches install.sh json-safe.mjs approach (simple regex version).
+function _stripJsonc(text) {
+  return text
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/\/\/[^\n]*/g, '')
+    .replace(/,(\s*[}\]])/g, '$1');
+}
+
+/**
+ * Idempotently write (or update) the claws entry in <projectRoot>/.mcp.json.
+ * Preserves all other mcpServers entries. Atomic write (tmp + rename).
+ * Uses absolute path for args so the MCP server resolves correctly regardless
+ * of the cwd from which Claude Code is launched (matches install.sh behavior).
+ * @param {string} projectRoot
+ * @param {boolean} [dryRun]
+ */
+function writeMcpJson(projectRoot, dryRun = false) {
+  const mcpPath = path.join(projectRoot, '.mcp.json');
+
+  if (dryRun) {
+    dryRunLog(`merge claws entry into ${mcpPath}`);
+    return;
+  }
+
+  let config = {};
+  if (fs.existsSync(mcpPath)) {
+    try {
+      config = JSON.parse(_stripJsonc(fs.readFileSync(mcpPath, 'utf8')));
+    } catch {
+      process.stderr.write(`  ! .mcp.json is malformed — preserving original, skipping merge\n`);
+      return;
+    }
+  }
+
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers.claws = {
+    command: 'node',
+    args: [path.join(projectRoot, '.claws-bin', 'mcp_server.js')],
+  };
+
+  const tmp = mcpPath + '.claws-tmp.' + process.pid;
+  fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + '\n', 'utf8');
+  fs.renameSync(tmp, mcpPath);
+
+  // W7h-27: re-read and parse after rename to catch any FS-level corruption.
+  // Matches install.sh:1090-1093.
+  try {
+    JSON.parse(fs.readFileSync(mcpPath, 'utf8'));
+  } catch (e) {
+    process.stderr.write(`  ! .mcp.json post-write validation failed: ${e.message}\n`);
+  }
+}
+
+/**
+ * Remove the claws entry from <projectRoot>/.mcp.json (uninstall path).
+ * @param {string} projectRoot
+ * @param {boolean} [dryRun]
+ */
+function removeMcpEntry(projectRoot, dryRun = false) {
+  const mcpPath = path.join(projectRoot, '.mcp.json');
+  if (!fs.existsSync(mcpPath)) return;
+
+  if (dryRun) {
+    dryRunLog(`remove claws entry from ${mcpPath}`);
+    return;
+  }
+
+  let config;
+  try {
+    config = JSON.parse(_stripJsonc(fs.readFileSync(mcpPath, 'utf8')));
+  } catch {
+    process.stderr.write(`  ! .mcp.json is malformed — skipping\n`);
+    return;
+  }
+
+  if (config.mcpServers && config.mcpServers.claws) {
+    delete config.mcpServers.claws;
+    const tmp = mcpPath + '.claws-tmp.' + process.pid;
+    fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + '\n', 'utf8');
+    fs.renameSync(tmp, mcpPath);
+  }
+}
+
+module.exports = { writeMcpJson, removeMcpEntry };

package/lib/platform.js

@@ -0,0 +1,240 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawnSync, execSync } = require('child_process');
+
+/**
+ * Find all installed editor CLIs (VS Code, Code Insiders, Cursor, Windsurf).
+ * Returns an array of { label, cliPath } for each editor found on the system.
+ * Mirrors install.sh's `for label in code code-insiders cursor windsurf` loop.
+ *
+ * Search order per editor:
+ *   1. CLAWS_VSCODE_CLI env override (code label only)
+ *   2. PATH lookup via which/where
+ *   3. Platform-specific known bundle/package locations
+ *
+ * @param {object} [_opts] - Internal overrides for testing only
+ * @returns {{ label: string, cliPath: string }[]}
+ */
+function findAllEditorClis(_opts = {}) {
+  const platform = _opts.platform !== undefined ? _opts.platform : process.platform;
+  const env      = _opts.env      !== undefined ? _opts.env      : process.env;
+  const existsFn = _opts.existsFn !== undefined ? _opts.existsFn : fs.existsSync;
+  const spawnFn  = _opts.spawnFn  !== undefined ? _opts.spawnFn  : spawnSync;
+
+  const localApp     = env.LOCALAPPDATA || '';
+  const programFiles = env.ProgramFiles  || 'C:\\Program Files';
+  const whichCmd     = platform === 'win32' ? 'where' : 'which';
+
+  const EDITORS = [
+    {
+      label:     'code',
+      macBundle: '/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code',
+      linux:     ['/usr/bin/code', '/snap/bin/code'],
+      win:       [
+        path.join(localApp,     'Programs', 'Microsoft VS Code', 'bin', 'Code.cmd'),
+        path.join(programFiles, 'Microsoft VS Code', 'bin', 'Code.cmd'),
+      ],
+    },
+    {
+      label:     'code-insiders',
+      macBundle: '/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/bin/code-insiders',
+      linux:     ['/usr/bin/code-insiders', '/snap/bin/code-insiders'],
+      win:       [
+        path.join(localApp,     'Programs', 'Microsoft VS Code Insiders', 'bin', 'Code - Insiders.cmd'),
+        path.join(programFiles, 'Microsoft VS Code Insiders', 'bin', 'Code - Insiders.cmd'),
+      ],
+    },
+    {
+      label:     'cursor',
+      macBundle: '/Applications/Cursor.app/Contents/Resources/app/bin/cursor',
+      linux:     ['/usr/bin/cursor', '/snap/bin/cursor', '/usr/local/bin/cursor'],
+      win:       [
+        path.join(localApp, 'Programs', 'cursor', 'cursor.cmd'),
+        path.join(localApp, 'cursor', 'resources', 'app', 'bin', 'cursor.cmd'),
+      ],
+    },
+    {
+      label:     'windsurf',
+      macBundle: '/Applications/Windsurf.app/Contents/Resources/app/bin/windsurf',
+      linux:     ['/usr/bin/windsurf', '/snap/bin/windsurf', '/usr/local/bin/windsurf'],
+      win:       [
+        path.join(localApp, 'Programs', 'Windsurf', 'windsurf.cmd'),
+      ],
+    },
+  ];
+
+  const results = [];
+  for (const editor of EDITORS) {
+    let found = null;
+
+    // 1. CLAWS_VSCODE_CLI env override (code label only — backward compat)
+    if (editor.label === 'code') {
+      const override = env.CLAWS_VSCODE_CLI;
+      if (override && existsFn(override)) found = override;
+    }
+
+    // 2. PATH lookup
+    if (!found) {
+      const r = spawnFn(whichCmd, [editor.label], { encoding: 'utf8', stdio: 'pipe' });
+      if (r.status === 0 && r.stdout) {
+        const first = r.stdout.trim().split('\n')[0];
+        if (first) found = first;
+      }
+    }
+
+    // 3. Platform-specific known bundle/package locations
+    if (!found) {
+      const candidates = platform === 'darwin'
+        ? (editor.macBundle ? [editor.macBundle] : [])
+        : platform === 'win32'
+          ? editor.win
+          : editor.linux;
+      for (const c of candidates) {
+        if (existsFn(c)) { found = c; break; }
+      }
+    }
+
+    if (found) results.push({ label: editor.label, cliPath: found });
+  }
+
+  return results;
+}
+
+/**
+ * Find the VS Code CLI executable path.
+ * Kept for backward compatibility — returns the first match from findAllEditorClis().
+ *
+ * @param {object} [_opts] - Internal overrides for testing only
+ * @returns {string|null}
+ */
+function findCodeCli(_opts = {}) {
+  const env      = _opts.env      !== undefined ? _opts.env      : process.env;
+  const existsFn = _opts.existsFn !== undefined ? _opts.existsFn : fs.existsSync;
+
+  // Env override takes precedence (retained for backward compat)
+  const override = env.CLAWS_VSCODE_CLI;
+  if (override && existsFn(override)) return override;
+
+  const found = findAllEditorClis(_opts);
+  return found.length > 0 ? found[0].cliPath : null;
+}
+
+/**
+ * Returns true if homeDir contains "OneDrive".
+ * @param {string} homeDir
+ * @returns {boolean}
+ */
+function detectOneDrivePath(homeDir) {
+  return homeDir.includes('OneDrive');
+}
+
+/**
+ * Returns a warning string when homeDir is suspiciously long (>100 chars) or
+ * OneDrive-rooted; returns null otherwise.
+ * @param {string} homeDir
+ * @returns {string|null}
+ */
+function longPathPreflight(homeDir) {
+  if (homeDir.length > 100) {
+    return `Warning: home directory path is very long (${homeDir.length} chars). Node on Windows may hit the 260-character path limit.`;
+  }
+  if (detectOneDrivePath(homeDir)) {
+    return `Warning: home directory appears to be OneDrive-synced (${homeDir}). Use fs.realpathSync() on all install paths to resolve symlinks.`;
+  }
+  return null;
+}
+
+/**
+ * Returns a PowerShell one-liner to add a Windows Defender exclusion for
+ * installPath; returns null on non-Windows.
+ * @param {string} installPath
+ * @param {object} [_opts] - Internal overrides for testing only
+ * @returns {string|null}
+ */
+function defenderExclusionCommand(installPath, _opts = {}) {
+  const platform = _opts.platform !== undefined ? _opts.platform : process.platform;
+  if (platform !== 'win32') return null;
+  return `Add-MpPreference -ExclusionPath "${installPath}"`;
+}
+
+/**
+ * Returns the default shell rc-file path for the current user.
+ *
+ * Platform mapping:
+ *   zsh  → ~/.zshrc
+ *   bash → ~/.bashrc
+ *   fish → ~/.config/fish/conf.d/claws.fish  (conf.d is auto-sourced by fish)
+ *   win32 PowerShell → $PROFILE (resolved via powershell -c $PROFILE)
+ *
+ * @param {object} [_opts] - Internal overrides for testing only
+ * @returns {string}
+ */
+function getDefaultShellRcFile(_opts = {}) {
+  const platform = _opts.platform !== undefined ? _opts.platform : process.platform;
+  const env      = _opts.env      !== undefined ? _opts.env      : process.env;
+  const home     = _opts.home     !== undefined ? _opts.home     : os.homedir();
+  const execFn   = _opts.execFn   !== undefined ? _opts.execFn   : execSync;
+
+  if (platform === 'win32') {
+    try {
+      const profile = execFn('powershell -c $PROFILE', { encoding: 'utf8' }).trim();
+      if (profile) return profile;
+    } catch (_) {
+      // powershell not available — use canonical default
+    }
+    return path.join(home, 'Documents', 'WindowsPowerShell', 'Microsoft.PowerShell_profile.ps1');
+  }
+
+  const shell = env.SHELL || '';
+  if (shell.includes('zsh'))  return path.join(home, '.zshrc');
+  if (shell.includes('fish')) return path.join(home, '.config', 'fish', 'conf.d', 'claws.fish');
+  if (shell.includes('bash')) return path.join(home, '.bashrc');
+
+  // No $SHELL set — fall back by platform
+  if (platform === 'darwin') return path.join(home, '.zshrc');
+  return path.join(home, '.bashrc');
+}
+
+/**
+ * Dry-run logger — writes a [dry-run] prefixed line to stdout.
+ * Used throughout the installer when --dry-run is active.
+ * @param {string} msg
+ */
+function dryRunLog(msg) {
+  process.stdout.write(`[dry-run] ${msg}\n`);
+}
+
+/**
+ * Detect the node-pty prebuild key for the current platform and architecture.
+ * Maps os.platform() + os.arch() to the directory name used by bundle-native.mjs:
+ *   darwin-x64 | darwin-arm64 | linux-x64 | linux-arm64
+ * Mirrors the case block in scripts/install.sh (CLAWS_PLATFORM_ARCH).
+ * @param {object} [_opts]
+ * @param {string} [_opts.platform]  - os.platform() override for testing
+ * @param {string} [_opts.arch]      - os.arch() override for testing
+ * @returns {string}
+ */
+function detectPlatformArch(_opts = {}) {
+  const platform = _opts.platform !== undefined ? _opts.platform : os.platform();
+  const arch     = _opts.arch     !== undefined ? _opts.arch     : os.arch();
+  const normArch = arch === 'arm64' ? 'arm64' : 'x64';
+  switch (platform) {
+    case 'darwin': return `darwin-${normArch}`;
+    case 'linux':  return `linux-${normArch}`;
+    default:       return 'linux-x64';
+  }
+}
+
+module.exports = {
+  findCodeCli,
+  findAllEditorClis,
+  detectOneDrivePath,
+  longPathPreflight,
+  defenderExclusionCommand,
+  getDefaultShellRcFile,
+  dryRunLog,
+  detectPlatformArch,
+};

package/lib/preflight.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const { spawnSync } = require('child_process');
+
+/**
+ * Run preflight checks. Returns { failures, warnings }.
+ * failures → hard errors that abort the install.
+ * warnings → WARN-not-block advisories printed before continuing.
+ *
+ * VS Code CLI presence is intentionally NOT checked here — a missing editor CLI
+ * is a soft warning emitted by _installExtension itself (phase 7), not a
+ * hard failure. install.sh behaves the same way (warn + continue).
+ *
+ * @param {object} [opts]
+ * @returns {{ failures: string[], warnings: string[] }}
+ */
+function run(opts = {}) {
+  const failures = [];
+  const warnings = [];
+
+  // ── Hard failures ──────────────────────────────────────────────────────────
+
+  // Node >= 18
+  const major = Number(process.versions.node.split('.')[0]);
+  if (major < 18) {
+    failures.push(`Node.js ≥ 18 required (found ${process.version})`);
+  }
+
+  // git in PATH (any version — version check is a soft warning below)
+  const git = spawnSync('git', ['--version'], { encoding: 'utf8', stdio: 'pipe' });
+  if (git.status !== 0) {
+    failures.push('git not found — install git: https://git-scm.com');
+  }
+
+  // HOME writable
+  const home = os.homedir();
+  try {
+    fs.accessSync(home, fs.constants.W_OK);
+  } catch {
+    failures.push(`Home directory not writable: ${home}`);
+  }
+
+  // ── Soft warnings (WARN-not-block) ──────────────────────────────────────
+
+  // git >= 2
+  if (git.status === 0) {
+    const m = (git.stdout || '').match(/git version (\d+)/);
+    if (m && Number(m[1]) < 2) {
+      warnings.push(`git ≥ 2 recommended (found ${(git.stdout || '').trim()}) — some git operations may fail`);
+    }
+  }
+
+  // npm >= 7
+  const npm = spawnSync('npm', ['--version'], { encoding: 'utf8', stdio: 'pipe' });
+  if (npm.status === 0) {
+    const npmMajor = Number((npm.stdout || '').trim().split('.')[0]);
+    if (npmMajor < 7) {
+      warnings.push(`npm ≥ 7 recommended (found ${(npm.stdout || '').trim()}) — some install steps may fail`);
+    }
+  } else {
+    warnings.push('npm not found in PATH — extension build may fail');
+  }
+
+  // C++ toolchain (needed by node-gyp / @electron/rebuild)
+  _checkCppToolchain(warnings);
+
+  // python3 (node-gyp fallback); on Windows Python 3 ships as `python`, try that as fallback
+  const py = spawnSync('python3', ['--version'], { encoding: 'utf8', stdio: 'pipe' });
+  if (py.status !== 0) {
+    const pyFallback = spawnSync('python', ['--version'], { encoding: 'utf8', stdio: 'pipe' });
+    const pyFallbackOut = (pyFallback.stdout || '') + (pyFallback.stderr || '');
+    if (pyFallback.status !== 0 || !pyFallbackOut.includes('Python 3')) {
+      warnings.push('python3 not found — node-gyp builds may fail if native modules need recompiling');
+    }
+  }
+
+  // Disk space >= 512 MB free in HOME
+  _checkDiskSpace(home, warnings);
+
+  return { failures, warnings };
+}
+
+/**
+ * Check for a C++ build toolchain. Emits a warning (not a failure) if missing.
+ * darwin: Xcode Command Line Tools (clang)
+ * linux:  g++ or make
+ * win32:  cl.exe or msbuild.exe (install.ps1 already handles this for Windows)
+ * @param {string[]} warnings
+ */
+function _checkCppToolchain(warnings) {
+  const platform = process.platform;
+
+  if (platform === 'win32') {
+    const cl       = spawnSync('cl.exe',      [], { encoding: 'utf8', stdio: 'pipe' });
+    const msbuild  = spawnSync('msbuild.exe', [], { encoding: 'utf8', stdio: 'pipe' });
+    if (cl.status === null && msbuild.status === null) {
+      warnings.push(
+        'C++ build tools not found (cl.exe / msbuild.exe) — run: winget install Microsoft.VisualStudio.BuildTools'
+      );
+    }
+    return;
+  }
+
+  if (platform === 'darwin') {
+    const clang = spawnSync('clang', ['--version'], { encoding: 'utf8', stdio: 'pipe' });
+    if (clang.status !== 0) {
+      warnings.push(
+        'Xcode Command Line Tools not found — run: xcode-select --install'
+      );
+    }
+    return;
+  }
+
+  // linux
+  const gpp  = spawnSync('g++',  ['--version'], { encoding: 'utf8', stdio: 'pipe' });
+  const make = spawnSync('make', ['--version'], { encoding: 'utf8', stdio: 'pipe' });
+  if (gpp.status !== 0 || make.status !== 0) {
+    warnings.push(
+      'C++ build tools not found (g++ / make) — run: sudo apt-get install build-essential  (or distro equivalent)'
+    );
+  }
+}
+
+/**
+ * Check free disk space in the given directory. Warns if < 512 MB.
+ * Uses `df -k` on POSIX; skips silently on win32.
+ * @param {string} dir
+ * @param {string[]} warnings
+ */
+function _checkDiskSpace(dir, warnings) {
+  if (process.platform === 'win32') return;
+
+  const df = spawnSync('df', ['-k', dir], { encoding: 'utf8', stdio: 'pipe' });
+  if (df.status !== 0) return;
+
+  const lines = (df.stdout || '').trim().split('\n');
+  if (lines.length < 2) return;
+
+  // df -k output: Filesystem 1K-blocks Used Available Capacity Mounted
+  // column index 3 is "Available" in blocks of 1024 bytes.
+  const cols = lines[lines.length - 1].trim().split(/\s+/);
+  const freeKb = Number(cols[3]);
+  if (!isNaN(freeKb) && freeKb < 512 * 1024) {
+    warnings.push(
+      `Low disk space: ${Math.round(freeKb / 1024)} MB free in ${dir} (512 MB recommended)`
+    );
+  }
+}
+
+module.exports = { run };