espcli 0.0.1 → 0.0.3

package/src/core/services/health.ts

@@ -1,214 +0,0 @@
-import { execa } from 'execa';
-import { readdir, access, readFile } from 'fs/promises';
-import { join } from 'path';
-
-export interface HealthStatus {
-  ok: boolean;
-  name: string;
-  version?: string;
-  path?: string;
-  error?: string;
-  hint?: string;
-}
-
-export interface SystemHealth {
-  python: HealthStatus;
-  idf: HealthStatus;
-  pyserial: HealthStatus;
-  esptool: HealthStatus;
-  git: HealthStatus;
-  idfPython?: string; // Path to IDF's Python environment
-}
-
-let healthCache: SystemHealth | null = null;
-
-export async function getHealth(): Promise<SystemHealth> {
-  if (healthCache) return healthCache;
-
-  healthCache = await runHealthChecks();
-  return healthCache;
-}
-
-export function clearHealthCache(): void {
-  healthCache = null;
-}
-
-async function runHealthChecks(): Promise<SystemHealth> {
-  // Run checks in parallel for speed
-  const [python, git] = await Promise.all([checkPython(), checkGit()]);
-
-  // IDF check depends on knowing if Python exists
-  const idf = await checkIdf();
-
-  // These depend on IDF Python environment
-  const idfPython = idf.ok ? await findIdfPython() : undefined;
-  const [pyserial, esptool] = idfPython
-    ? await Promise.all([checkPyserial(idfPython), checkEsptool(idfPython)])
-    : [
-        { ok: false, name: 'pyserial', error: 'ESP-IDF not installed', hint: 'Run: espcli install' },
-        { ok: false, name: 'esptool', error: 'ESP-IDF not installed', hint: 'Run: espcli install' },
-      ];
-
-  return { python, idf, pyserial, esptool, git, idfPython };
-}
-
-async function checkPython(): Promise<HealthStatus> {
-  try {
-    const { stdout } = await execa('python3', ['--version'], { timeout: 3000 });
-    const version = stdout.replace('Python ', '').trim();
-    return { ok: true, name: 'Python', version };
-  } catch {
-    return {
-      ok: false,
-      name: 'Python',
-      error: 'Python 3 not found',
-      hint: 'Install Python 3: https://www.python.org/downloads/',
-    };
-  }
-}
-
-async function checkGit(): Promise<HealthStatus> {
-  try {
-    const { stdout } = await execa('git', ['--version'], { timeout: 3000 });
-    const version = stdout.replace('git version ', '').trim();
-    return { ok: true, name: 'Git', version };
-  } catch {
-    return {
-      ok: false,
-      name: 'Git',
-      error: 'Git not found',
-      hint: 'Install Git: https://git-scm.com/downloads',
-    };
-  }
-}
-
-async function checkIdf(): Promise<HealthStatus> {
-  const home = process.env.HOME || '';
-  const possiblePaths = [
-    process.env.IDF_PATH,
-    join(home, 'esp', 'esp-idf'),
-    join(home, 'esp-idf'),
-  ].filter(Boolean) as string[];
-
-  for (const idfPath of possiblePaths) {
-    try {
-      await access(idfPath);
-
-      // Try to read version from version.txt or git
-      let version: string | undefined;
-      try {
-        const versionFile = join(idfPath, 'version.txt');
-        version = (await readFile(versionFile, 'utf-8')).trim();
-      } catch {
-        try {
-          const { stdout } = await execa('git', ['describe', '--tags'], {
-            cwd: idfPath,
-            timeout: 3000,
-          });
-          version = stdout.trim();
-        } catch {
-          version = 'unknown';
-        }
-      }
-
-      return { ok: true, name: 'ESP-IDF', version, path: idfPath };
-    } catch {
-      continue;
-    }
-  }
-
-  return {
-    ok: false,
-    name: 'ESP-IDF',
-    error: 'ESP-IDF not found',
-    hint: 'Run: espcli install',
-  };
-}
-
-async function findIdfPython(): Promise<string | undefined> {
-  const home = process.env.HOME || '';
-  const envDir = join(home, '.espressif', 'python_env');
-
-  try {
-    const files = await readdir(envDir);
-    for (const file of files) {
-      if (file.startsWith('idf')) {
-        const pythonPath = join(envDir, file, 'bin', 'python');
-        try {
-          await execa(pythonPath, ['--version'], { timeout: 2000 });
-          return pythonPath;
-        } catch {
-          continue;
-        }
-      }
-    }
-  } catch {
-    // Directory doesn't exist
-  }
-
-  return undefined;
-}
-
-async function checkPyserial(python: string): Promise<HealthStatus> {
-  try {
-    const { stdout } = await execa(
-      python,
-      ['-c', 'import serial; print(serial.__version__)'],
-      { timeout: 3000 }
-    );
-    return { ok: true, name: 'pyserial', version: stdout.trim() };
-  } catch {
-    return {
-      ok: false,
-      name: 'pyserial',
-      error: 'pyserial not installed in IDF environment',
-      hint: 'Reinstall ESP-IDF: espcli install',
-    };
-  }
-}
-
-async function checkEsptool(python: string): Promise<HealthStatus> {
-  try {
-    const { stdout } = await execa(python, ['-m', 'esptool', 'version'], {
-      timeout: 3000,
-    });
-    // Parse version from "esptool.py v4.8.1"
-    const versionMatch = stdout.match(/v?([\d.]+)/);
-    const version = versionMatch?.[1] || 'unknown';
-    return { ok: true, name: 'esptool', version };
-  } catch {
-    return {
-      ok: false,
-      name: 'esptool',
-      error: 'esptool not installed in IDF environment',
-      hint: 'Reinstall ESP-IDF: espcli install',
-    };
-  }
-}
-
-export async function requireIdf(): Promise<{ ok: true; python: string } | { ok: false; error: string }> {
-  const health = await getHealth();
-
-  if (!health.idf.ok) {
-    return { ok: false, error: `${health.idf.error}. ${health.idf.hint}` };
-  }
-
-  if (!health.idfPython) {
-    return { ok: false, error: 'ESP-IDF Python environment not found. Run: espcli install' };
-  }
-
-  return { ok: true, python: health.idfPython };
-}
-
-export async function requireTool(
-  tool: 'python' | 'git' | 'idf' | 'pyserial' | 'esptool'
-): Promise<{ ok: true } | { ok: false; error: string }> {
-  const health = await getHealth();
-  const status = health[tool];
-
-  if (!status.ok) {
-    return { ok: false, error: `${status.error}. ${status.hint}` };
-  }
-
-  return { ok: true };
-}

package/src/core/services/idf.ts

@@ -1,98 +0,0 @@
-import type { IdfStatus, Result } from '@/core/types';
-import { DEFAULT_IDF_PATH } from '@/core/constants';
-import { access, readFile } from 'fs/promises';
-import { join, dirname } from 'path';
-import { execa } from 'execa';
-
-export async function findIdfPath(): Promise<string | null> {
-  if (process.env.IDF_PATH) {
-    try {
-      await access(process.env.IDF_PATH);
-      return process.env.IDF_PATH;
-    } catch {}
-  }
-
-  try {
-    await access(DEFAULT_IDF_PATH);
-    return DEFAULT_IDF_PATH;
-  } catch {}
-
-  return null;
-}
-
-export async function getIdfVersion(idfPath: string): Promise<string | null> {
-  const versionFile = join(idfPath, 'version.txt');
-
-  try {
-    const content = await readFile(versionFile, 'utf-8');
-    return content.trim();
-  } catch {}
-
-  try {
-    const result = await execa('git', ['describe', '--tags'], { cwd: idfPath });
-    return result.stdout.trim();
-  } catch {}
-
-  return null;
-}
-
-export async function getIdfStatus(): Promise<IdfStatus> {
-  const path = await findIdfPath();
-
-  if (!path) {
-    return { installed: false };
-  }
-
-  const version = await getIdfVersion(path);
-
-  return {
-    installed: true,
-    path,
-    version: version || undefined,
-  };
-}
-
-export async function isIdfProject(dir: string): Promise<boolean> {
-  const cmakePath = join(dir, 'CMakeLists.txt');
-
-  try {
-    const content = await readFile(cmakePath, 'utf-8');
-    return content.includes('$ENV{IDF_PATH}') || content.includes('idf_component_register');
-  } catch {
-    return false;
-  }
-}
-
-export async function findProjectRoot(startDir: string): Promise<string | null> {
-  let current = startDir;
-
-  while (current !== dirname(current)) {
-    if (await isIdfProject(current)) {
-      return current;
-    }
-    current = dirname(current);
-  }
-
-  return null;
-}
-
-export function getExportScript(idfPath: string): string {
-  return join(idfPath, 'export.sh');
-}
-
-export async function validateIdfInstallation(idfPath: string): Promise<Result<void>> {
-  try {
-    await access(idfPath);
-  } catch {
-    return { ok: false, error: `IDF path does not exist: ${idfPath}` };
-  }
-
-  const exportScript = getExportScript(idfPath);
-  try {
-    await access(exportScript);
-  } catch {
-    return { ok: false, error: `export.sh not found in ${idfPath}` };
-  }
-
-  return { ok: true, data: undefined };
-}

package/src/core/services/ports.ts

@@ -1,172 +0,0 @@
-import type { SerialDevice, ConnectionType } from '@/core/types';
-import { USB_VENDORS } from '@/core/constants';
-import { requireIdf } from '@/core/services/health';
-import { execa } from 'execa';
-
-// Espressif's USB Vendor ID (0x303A = 12346 decimal)
-// @see https://github.com/espressif/usb-pids
-const ESPRESSIF_VID = '303A';
-
-/**
- * List serial ports and detect connected ESP32 chips
- *
- * Uses pyserial's CLI: python -m serial.tools.list_ports -v
- * Output format:
- *   /dev/cu.usbmodem1101
- *       desc: USB JTAG/serial debug unit
- *       hwid: USB VID:PID=303A:1001 SER=C0:4E:30:37:1B:BC LOCATION=1-1
- *
- * @see https://pyserial.readthedocs.io/en/latest/tools.html#module-serial.tools.list_ports
- */
-export async function listPorts(): Promise<SerialDevice[]> {
-  const idf = await requireIdf();
-  if (!idf.ok) return []; // IDF not installed
-
-  const python = idf.python;
-
-  try {
-    // pyserial CLI tool - cross-platform serial port enumeration
-    // @see https://github.com/pyserial/pyserial/blob/master/serial/tools/list_ports.py
-    const { stdout } = await execa(python, ['-m', 'serial.tools.list_ports', '-v'], {
-      timeout: 5000,
-    });
-
-    const devices: SerialDevice[] = [];
-    const lines = stdout.split('\n');
-
-    let currentPort: string | null = null;
-    let desc = '';
-    let hwid = '';
-
-    for (const line of lines) {
-      if (line.startsWith('/dev/')) {
-        // Save previous device if exists
-        if (currentPort) {
-          const device = parseDevice(currentPort, desc, hwid);
-          if (device) devices.push(device);
-        }
-        currentPort = line.trim();
-        desc = '';
-        hwid = '';
-      } else if (line.includes('desc:')) {
-        desc = line.split('desc:')[1]?.trim() || '';
-      } else if (line.includes('hwid:')) {
-        hwid = line.split('hwid:')[1]?.trim() || '';
-      }
-    }
-
-    // Don't forget last device
-    if (currentPort) {
-      const device = parseDevice(currentPort, desc, hwid);
-      if (device) devices.push(device);
-    }
-
-    // Detect ESP chips for all compatible devices
-    return await detectEspChips(python, devices);
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Parse device info from pyserial output
- */
-function parseDevice(port: string, desc: string, hwid: string): SerialDevice | null {
-  // Skip non-USB ports (Bluetooth, debug-console, etc.)
-  if (hwid === 'n/a' || !hwid.includes('VID:PID=')) {
-    return null;
-  }
-
-  // Parse VID:PID from hwid like "USB VID:PID=303A:1001 SER=... LOCATION=..."
-  const vidPidMatch = hwid.match(/VID:PID=([0-9A-Fa-f]+):([0-9A-Fa-f]+)/);
-  const vendorId = vidPidMatch?.[1]?.toUpperCase();
-  const productId = vidPidMatch?.[2]?.toUpperCase();
-
-  const connectionType = getConnectionType(vendorId);
-  const chip = identifyChip(vendorId, productId);
-
-  return {
-    port,
-    connectionType,
-    vendorId,
-    productId,
-    manufacturer: USB_VENDORS[vendorId || '']?.name,
-    chip,
-    description: desc !== 'n/a' ? desc : undefined,
-  };
-}
-
-function getConnectionType(vendorId?: string): ConnectionType {
-  if (!vendorId) return 'unknown';
-  return vendorId.toUpperCase() === ESPRESSIF_VID ? 'native-usb' : 'uart-bridge';
-}
-
-function identifyChip(vendorId?: string, productId?: string): string | undefined {
-  if (!vendorId) return undefined;
-
-  const vendor = USB_VENDORS[vendorId.toUpperCase()];
-  if (!vendor) return undefined;
-
-  if (productId) {
-    const chip = vendor.chips[productId.toUpperCase()];
-    if (chip) return chip;
-  }
-
-  return vendor.name;
-}
-
-/**
- * @see https://github.com/espressif/esptool#chip-id
- */
-async function detectEspChips(python: string, devices: SerialDevice[]): Promise<SerialDevice[]> {
-  const results = await Promise.all(
-    devices.map(async (device) => {
-      // Only detect on ESP-compatible ports
-      const isEspCompatible =
-        device.connectionType === 'native-usb' ||
-        device.chip?.includes('CH34') ||
-        device.chip?.includes('CP210') ||
-        device.chip?.includes('FT232') ||
-        device.chip?.includes('CH9');
-
-      if (isEspCompatible) {
-        const espChip = await detectEspChip(python, device.port);
-        return { ...device, espChip };
-      }
-
-      return device;
-    })
-  );
-
-  return results;
-}
-
-/**
- * @see https://github.com/espressif/esptool/blob/master/esptool/cmds.py (chip_id command)
- * @see https://github.com/espressif/esptool/tree/master/esptool/targets (chip definitions)
- */
-async function detectEspChip(python: string, port: string): Promise<string | undefined> {
-  try {
-    const { stdout, stderr } = await execa(python, ['-m', 'esptool', '--port', port, 'chip_id'], {
-      timeout: 10000,
-      reject: false,
-    });
-
-    const output = stdout + stderr;
-
-    const patterns = [
-      /Chip is (ESP32[A-Za-z0-9-]*)/i, // "Chip is ESP32-S3 (revision v0.2)"
-      /Detecting chip type[.\s]*(ESP32[A-Za-z0-9-]*)/i, // "Detecting chip type... ESP32-S3"
-      /Chip type:\s*(ESP32[A-Za-z0-9-]*)/i, // "Chip type: ESP32-S3"
-    ];
-
-    for (const pattern of patterns) {
-      const match = output.match(pattern);
-      if (match) return match[1].toUpperCase();
-    }
-  } catch {
-    // esptool failed (port busy, chip not responding, etc.)
-  }
-
-  return undefined;
-}

package/src/core/services/process.ts

@@ -1,144 +0,0 @@
-import type { Result } from '@/core/types';
-import { execa, type Options as ExecaOptions, type ResultPromise } from 'execa';
-import { findIdfPath, getExportScript } from '@/core/services/idf';
-import { emitter } from '@/core/emitter';
-
-export interface RunOptions {
-  cwd?: string;
-  operationId?: string;
-  env?: Record<string, string>;
-}
-
-export interface RunResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}
-
-export async function run(
-  command: string,
-  args: string[],
-  options: RunOptions = {}
-): Promise<Result<RunResult>> {
-  const { cwd, operationId, env } = options;
-
-  const execaOpts: ExecaOptions = {
-    cwd,
-    env: { ...process.env, ...env },
-    reject: false,
-  };
-
-  try {
-    const proc = execa(command, args, execaOpts);
-
-    if (operationId) {
-      proc.stdout?.on('data', (data: Buffer) => {
-        emitter.emit(operationId, { type: 'stdout', text: data.toString() });
-      });
-
-      proc.stderr?.on('data', (data: Buffer) => {
-        emitter.emit(operationId, { type: 'stderr', text: data.toString() });
-      });
-    }
-
-    const result = await proc;
-
-    return {
-      ok: true,
-      data: {
-        stdout: String(result.stdout ?? ''),
-        stderr: String(result.stderr ?? ''),
-        exitCode: result.exitCode ?? 0,
-      },
-    };
-  } catch (err) {
-    return { ok: false, error: `Failed to execute ${command}: ${err}` };
-  }
-}
-
-export async function runWithIdf(
-  command: string,
-  args: string[],
-  options: RunOptions = {}
-): Promise<Result<RunResult>> {
-  const idfPath = await findIdfPath();
-
-  if (!idfPath) {
-    return { ok: false, error: 'ESP-IDF not found. Run `espcli install` first.', code: 'IDF_NOT_FOUND' };
-  }
-
-  const exportScript = getExportScript(idfPath);
-  const fullCommand = `source ${exportScript} > /dev/null 2>&1 && ${command} ${args.join(' ')}`;
-
-  const { cwd, operationId, env } = options;
-
-  const execaOpts: ExecaOptions = {
-    cwd,
-    env: { ...process.env, ...env },
-    shell: true,
-    reject: false,
-  };
-
-  try {
-    const proc = execa(fullCommand, [], execaOpts);
-
-    if (operationId) {
-      proc.stdout?.on('data', (data: Buffer) => {
-        emitter.emit(operationId, { type: 'stdout', text: data.toString() });
-      });
-
-      proc.stderr?.on('data', (data: Buffer) => {
-        emitter.emit(operationId, { type: 'stderr', text: data.toString() });
-      });
-    }
-
-    const result = await proc;
-
-    return {
-      ok: true,
-      data: {
-        stdout: String(result.stdout ?? ''),
-        stderr: String(result.stderr ?? ''),
-        exitCode: result.exitCode ?? 0,
-      },
-    };
-  } catch (err) {
-    return { ok: false, error: `Failed to execute ${command}: ${err}` };
-  }
-}
-
-export function spawnWithIdf(
-  command: string,
-  args: string[],
-  options: RunOptions = {}
-): ResultPromise | null {
-  const idfPath = process.env.IDF_PATH;
-
-  if (!idfPath) {
-    return null;
-  }
-
-  const exportScript = getExportScript(idfPath);
-  const fullCommand = `source ${exportScript} > /dev/null 2>&1 && ${command} ${args.join(' ')}`;
-
-  const { cwd, operationId, env } = options;
-
-  const proc = execa(fullCommand, [], {
-    cwd,
-    env: { ...process.env, ...env },
-    shell: true,
-    reject: false,
-  });
-
-  if (operationId) {
-    proc.stdout?.on('data', (data: Buffer) => {
-      emitter.emit(operationId, { type: 'stdout', text: data.toString() });
-    });
-
-    proc.stderr?.on('data', (data: Buffer) => {
-      emitter.emit(operationId, { type: 'stderr', text: data.toString() });
-    });
-  }
-
-  return proc;
-}

package/src/core/services/shell.ts

@@ -1,74 +0,0 @@
-import type { ShellInfo, ShellType, Result } from '@/core/types';
-import { SHELL_CONFIGS } from '@/core/constants';
-import { homedir } from 'os';
-import { join } from 'path';
-import { readFile, appendFile, access } from 'fs/promises';
-
-export function detectShell(): ShellType {
-  const shell = process.env.SHELL || '';
-  if (shell.includes('zsh')) return 'zsh';
-  if (shell.includes('bash')) return 'bash';
-  if (shell.includes('fish')) return 'fish';
-  return 'unknown';
-}
-
-export function getShellInfo(): ShellInfo {
-  const type = detectShell();
-  const configFile = SHELL_CONFIGS[type] || '';
-  const configPath = configFile ? join(homedir(), configFile) : '';
-
-  return { type, configPath };
-}
-
-export async function shellConfigExists(): Promise<boolean> {
-  const { configPath } = getShellInfo();
-  if (!configPath) return false;
-
-  try {
-    await access(configPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function isLineInShellConfig(line: string): Promise<boolean> {
-  const { configPath } = getShellInfo();
-  if (!configPath) return false;
-
-  try {
-    const content = await readFile(configPath, 'utf-8');
-    return content.includes(line);
-  } catch {
-    return false;
-  }
-}
-
-export async function addToShellConfig(line: string): Promise<Result<void>> {
-  const { configPath, type } = getShellInfo();
-
-  if (!configPath) {
-    return { ok: false, error: `Unsupported shell: ${type}` };
-  }
-
-  const alreadyExists = await isLineInShellConfig(line);
-  if (alreadyExists) {
-    return { ok: true, data: undefined };
-  }
-
-  try {
-    await appendFile(configPath, `\n${line}\n`);
-    return { ok: true, data: undefined };
-  } catch (err) {
-    return { ok: false, error: `Failed to modify ${configPath}: ${err}` };
-  }
-}
-
-export function getExportCommand(idfPath: string): string {
-  const shellType = detectShell();
-
-  if (shellType === 'fish') {
-    return `source ${idfPath}/export.fish`;
-  }
-  return `. ${idfPath}/export.sh`;
-}