cc-env-checker 0.1.0

package/src/checks/helpers.js

@@ -0,0 +1,326 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import dns from 'node:dns/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+export function createCheckResult({
+  id,
+  title,
+  titleKey,
+  status,
+  riskLevel,
+  evidenceType,
+  source,
+  summary,
+  summaryKey,
+  details = [],
+  suggestion = '',
+  suggestionKey,
+  messageParams = {},
+}) {
+  return {
+    id,
+    title,
+    titleKey,
+    status,
+    riskLevel,
+    evidenceType,
+    source,
+    summary,
+    summaryKey,
+    details,
+    suggestion,
+    suggestionKey,
+    messageParams,
+  };
+}
+
+export async function tryExec(command, args = []) {
+  try {
+    const result = await execFileAsync(command, args, {
+      timeout: 5_000,
+      env: process.env,
+    });
+
+    return {
+      ok: true,
+      stdout: result.stdout.trim(),
+      stderr: result.stderr.trim(),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      code: error.code,
+      stdout: String(error.stdout ?? '').trim(),
+      stderr: String(error.stderr ?? '').trim(),
+      message: error.message,
+    };
+  }
+}
+
+export async function safeReadJson(filePath) {
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    return {
+      ok: true,
+      data: JSON.parse(content),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      code: error.code,
+      message: error.message,
+    };
+  }
+}
+
+export function maskValue(value, { start = 4, end = 4 } = {}) {
+  const text = String(value ?? '');
+
+  if (!text) {
+    return 'masked:empty';
+  }
+
+  if (text.length <= start + end) {
+    return `${text.slice(0, 1)}***`;
+  }
+
+  return `${text.slice(0, start)}***${text.slice(-end)}`;
+}
+
+export async function summarizeDirectory(dirPath) {
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    const names = entries.map((entry) => entry.name).sort();
+
+    return {
+      ok: true,
+      entryCount: entries.length,
+      sample: names.slice(0, 5),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      code: error.code,
+      message: error.message,
+    };
+  }
+}
+
+export function sha256Prefix(value, length = 16) {
+  return crypto.createHash('sha256').update(String(value)).digest('hex').slice(0, length);
+}
+
+function getPlatformPath(platform) {
+  return platform === 'win32' ? path.win32 : path.posix;
+}
+
+function getPathExts(platform, env = process.env) {
+  if (platform !== 'win32') {
+    return [''];
+  }
+
+  return (env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD')
+    .split(';')
+    .map((ext) => ext.trim())
+    .filter(Boolean);
+}
+
+function uniquePush(values, candidate) {
+  if (candidate && !values.includes(candidate)) {
+    values.push(candidate);
+  }
+}
+
+function buildExecutableCandidates(command, { platform, env } = {}) {
+  const pathApi = getPlatformPath(platform);
+  const executable = String(command ?? '').trim();
+  const exts = getPathExts(platform, env);
+  const candidates = [];
+  const hasExtension = pathApi.extname(executable) !== '';
+  const hasSeparator = executable.includes('/') || executable.includes('\\');
+  const isAbsolute = path.posix.isAbsolute(executable) || path.win32.isAbsolute(executable);
+  const pathDirs = String(env.PATH ?? env.Path ?? '')
+    .split(pathApi.delimiter)
+    .filter(Boolean);
+
+  if (hasSeparator || isAbsolute) {
+    uniquePush(candidates, executable);
+    if (platform === 'win32' && !hasExtension) {
+      for (const ext of exts) {
+        uniquePush(candidates, `${executable}${ext.toLowerCase()}`);
+      }
+    }
+    return candidates;
+  }
+
+  for (const dir of pathDirs) {
+    if (platform === 'win32') {
+      uniquePush(candidates, pathApi.join(dir, executable));
+      if (!hasExtension) {
+        for (const ext of exts) {
+          uniquePush(candidates, pathApi.join(dir, `${executable}${ext.toLowerCase()}`));
+        }
+      }
+      continue;
+    }
+
+    uniquePush(candidates, pathApi.join(dir, executable));
+  }
+
+  return candidates;
+}
+
+export async function resolveExecutable(command, { access = fs.access, platform = process.platform, env = process.env } = {}) {
+  const executable = String(command ?? '').trim();
+
+  if (!executable) {
+    return { ok: false, message: 'command is required' };
+  }
+
+  for (const candidate of buildExecutableCandidates(executable, { platform, env })) {
+    try {
+      const mode = platform === 'win32' ? fsConstants.F_OK : fsConstants.X_OK;
+      await access(candidate, mode);
+      return { ok: true, path: candidate };
+    } catch {
+      continue;
+    }
+  }
+
+  return { ok: false, message: `${executable} not found` };
+}
+
+export async function readTextIfExists(filePath) {
+  try {
+    const text = await fs.readFile(filePath, 'utf8');
+    return {
+      ok: true,
+      text,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      code: error.code,
+      message: error.message,
+    };
+  }
+}
+
+export function extractMatches(text, patterns) {
+  const matches = new Set();
+  const escapeRegExp = (value) => String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+  for (const pattern of patterns) {
+    if (typeof pattern === 'string' && pattern.length === 0) {
+      continue;
+    }
+
+    const regex = pattern instanceof RegExp
+      ? new RegExp(pattern.source, pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`)
+      : new RegExp(escapeRegExp(pattern), 'g');
+
+    for (const match of String(text).matchAll(regex)) {
+      matches.add(match[0]);
+    }
+  }
+
+  return [...matches].sort();
+}
+
+export function proxyEnvSnapshot(env = process.env) {
+  return ['HTTP_PROXY', 'HTTPS_PROXY', 'ALL_PROXY', 'NO_PROXY']
+    .filter((key) => env[key])
+    .map((key) => `${key}=${env[key]}`);
+}
+
+export function runtimeSnapshot() {
+  return [
+    `platform=${process.platform}`,
+    `arch=${process.arch}`,
+    `node=${process.version}`,
+    `hostname=${os.hostname()}`,
+  ];
+}
+
+export async function resolveHost(hostname) {
+  try {
+    const [v4, v6] = await Promise.allSettled([
+      dns.resolve4(hostname),
+      dns.resolve6(hostname),
+    ]);
+
+    return {
+      ok: true,
+      v4: v4.status === 'fulfilled' ? v4.value : [],
+      v6: v6.status === 'fulfilled' ? v6.value : [],
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error.message,
+      v4: [],
+      v6: [],
+    };
+  }
+}
+
+export async function fetchJson(url, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        'user-agent': 'cc-env-checker/0.1.0',
+      },
+    });
+
+    return {
+      ok: response.ok,
+      status: response.status,
+      data: await response.json(),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error.name === 'AbortError' ? 'request timed out' : error.message,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function fetchText(url, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        'user-agent': 'cc-env-checker/0.1.0',
+      },
+    });
+
+    return {
+      ok: response.ok,
+      status: response.status,
+      text: await response.text(),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error.name === 'AbortError' ? 'request timed out' : error.message,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/checks/install.js

@@ -0,0 +1,72 @@
+import { createCheckResult, tryExec } from './helpers.js';
+
+async function checkClaudeBinary() {
+  const versionResult = await tryExec('claude', ['--version']);
+
+  if (!versionResult.ok) {
+    return createCheckResult({
+      id: 'install.claude-binary',
+      titleKey: 'check.install.binary.title',
+      status: 'fail',
+      riskLevel: 'high',
+      evidenceType: 'observed',
+      source: 'local',
+      summaryKey: 'check.install.binary.summary.fail',
+      details: [versionResult.message],
+      suggestionKey: 'check.install.binary.suggestion.fail',
+    });
+  }
+
+  return createCheckResult({
+    id: 'install.claude-binary',
+    titleKey: 'check.install.binary.title',
+    status: 'pass',
+    riskLevel: 'low',
+    evidenceType: 'observed',
+    source: 'local',
+    summaryKey: 'check.install.binary.summary.pass',
+    details: [`version=${versionResult.stdout || 'unknown'}`],
+    suggestionKey: 'check.common.noAction',
+  });
+}
+
+async function checkClaudeHelp() {
+  const helpResult = await tryExec('claude', ['--help']);
+
+  if (!helpResult.ok) {
+    return createCheckResult({
+      id: 'install.claude-help',
+      titleKey: 'check.install.help.title',
+      status: 'warn',
+      riskLevel: 'medium',
+      evidenceType: 'observed',
+      source: 'local',
+      summaryKey: 'check.install.help.summary.warn',
+      details: [helpResult.message],
+      suggestionKey: 'check.install.help.suggestion.warn',
+    });
+  }
+
+  return createCheckResult({
+    id: 'install.claude-help',
+    titleKey: 'check.install.help.title',
+    status: 'pass',
+    riskLevel: 'low',
+    evidenceType: 'observed',
+    source: 'local',
+    summaryKey: 'check.install.help.summary.pass',
+    details: [`output-bytes=${helpResult.stdout.length}`],
+    suggestionKey: 'check.common.noAction',
+  });
+}
+
+export const installModule = {
+  id: 'install',
+  titleKey: 'module.install',
+  async run() {
+    return [
+      await checkClaudeBinary(),
+      await checkClaudeHelp(),
+    ];
+  },
+};