espcli 0.0.1 → 0.0.3

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "espcli",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Modern CLI for ESP-IDF development — install, create, build, flash, and monitor ESP32 projects",
-  "module": "src/index.ts",
   "type": "module",
   "scripts": {
     "dev": "bun run src/index.ts",
     "serve": "bun run src/serve.ts",
-    "build": "bun build ./src/index.ts --outdir ./dist --target bun --minify",
+    "build": "bun build ./src/index.ts --outdir ./dist --target node --minify",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
     "web": "cd web && bun run dev",
@@ -16,7 +15,7 @@
     "publish": "bun run build && bun publish --access public"
   },
   "bin": {
-    "espcli": "./src/index.ts"
+    "espcli": "./dist/index.js"
   },
   "devDependencies": {
     "@types/bun": "latest"
@@ -24,8 +23,8 @@
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
+  "types": "dist/index.d.ts",
   "files": [
-    "src",
     "dist"
   ],
   "repository": {

package/src/core/constants.ts

@@ -1,107 +0,0 @@
-import type { EspTarget } from '@/core/types';
-import { homedir } from 'os';
-import { join } from 'path';
-
-/**
- * Supported ESP32 target chips
- * @see https://github.com/espressif/esptool/blob/master/esptool/targets/__init__.py
- */
-export const ESP_TARGETS: EspTarget[] = [
-  // Xtensa-based chips
-  { id: 'esp32', name: 'ESP32', description: 'Original dual-core Xtensa', stable: true },
-  { id: 'esp32s2', name: 'ESP32-S2', description: 'Single-core Xtensa with USB OTG', stable: true },
-  { id: 'esp32s3', name: 'ESP32-S3', description: 'Dual-core Xtensa with AI acceleration', stable: true },
-  { id: 'esp32s31', name: 'ESP32-S3 (rev1)', description: 'ESP32-S3 revision 1', stable: false },
-
-  // RISC-V based chips
-  { id: 'esp32c2', name: 'ESP32-C2', description: 'Single-core RISC-V (cost-optimized)', stable: true },
-  { id: 'esp32c3', name: 'ESP32-C3', description: 'Single-core RISC-V', stable: true },
-  { id: 'esp32c5', name: 'ESP32-C5', description: 'RISC-V with WiFi 6', stable: false },
-  { id: 'esp32c6', name: 'ESP32-C6', description: 'RISC-V with WiFi 6 & 802.15.4', stable: true },
-  { id: 'esp32c61', name: 'ESP32-C61', description: 'ESP32-C6 variant', stable: false },
-
-  // 802.15.4/Thread/Zigbee chips
-  { id: 'esp32h2', name: 'ESP32-H2', description: 'RISC-V with 802.15.4/Zigbee/Thread', stable: true },
-  { id: 'esp32h21', name: 'ESP32-H21', description: 'ESP32-H2 variant', stable: false },
-  { id: 'esp32h4', name: 'ESP32-H4', description: 'RISC-V 802.15.4', stable: false },
-
-  // High-performance chips
-  { id: 'esp32p4', name: 'ESP32-P4', description: 'High-performance dual-core RISC-V', stable: false },
-];
-
-export const DEFAULT_IDF_PATH = join(homedir(), 'esp', 'esp-idf');
-export const DEFAULT_ESP_PATH = join(homedir(), 'esp');
-export const IDF_REPO_URL = 'https://github.com/espressif/esp-idf.git';
-
-export const DEFAULT_FLASH_BAUD = 460800;
-export const DEFAULT_MONITOR_BAUD = 115200;
-
-/**
- * USB Vendor/Product IDs for ESP32 development boards
- *
- * USB-IF Vendor IDs:
- * - 0x303A = Espressif Systems (registered USB vendor): https://github.com/espressif/usb-pids
- * - 0x10C4 = Silicon Labs (CP210x USB-UART bridges)
- * - 0x1A86 = QinHeng Electronics (CH340/CH343 USB-UART bridges)
- * - 0x0403 = FTDI (FT232 USB-UART bridges)
- *
- * References:
- * - USB ID Database: http://www.linux-usb.org/usb.ids
- * - Espressif USB PIDs: https://github.com/espressif/esptool/blob/master/esptool/loader.py
- *   (search for USB_JTAG_SERIAL_PID = 0x1001)
- *
- * Important: Espressif PIDs identify USB MODE, not specific chip variant:
- * - 0x1001 = USB-JTAG/Serial mode (used by ESP32-S2, S3, C3, C6, H2 with built-in USB)
- * - 0x1002 = USB-OTG mode (ESP32-S2, S3)
- * To identify the actual chip, use esptool.py chip_id command.
- */
-export const USB_VENDORS: Record<string, { name: string; chips: Record<string, string> }> = {
-  // Silicon Labs CP210x - common on older ESP32 dev boards
-  // @see https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers
-  '10C4': {
-    name: 'Silicon Labs',
-    chips: {
-      'EA60': 'CP210x',
-      'EA70': 'CP2105',
-    },
-  },
-  // WCH (QinHeng) CH340/CH343 - common on budget ESP32 boards
-  // @see https://www.wch-ic.com/products/CH343.html
-  '1A86': {
-    name: 'QinHeng Electronics',
-    chips: {
-      '7523': 'CH340',
-      '5523': 'CH341',
-      '55D3': 'CH343', // High-speed USB-UART, common on newer boards
-      '55D4': 'CH9102',
-    },
-  },
-  // FTDI - professional-grade USB-UART bridges
-  // @see https://ftdichip.com/products/ft232r/
-  '0403': {
-    name: 'FTDI',
-    chips: {
-      '6001': 'FT232R',
-      '6010': 'FT2232',
-      '6011': 'FT4232',
-      '6014': 'FT232H',
-    },
-  },
-  // Espressif native USB - built into ESP32-S2/S3/C3/C6/H2
-  // @see https://github.com/espressif/esptool/blob/master/esptool/loader.py#L77
-  '303A': {
-    name: 'Espressif',
-    chips: {
-      '1001': 'ESP32 (USB-JTAG)', // USB_JTAG_SERIAL_PID
-      '1002': 'ESP32 (USB-OTG)', // USB_OTG_PID
-    },
-  },
-};
-
-export const SHELL_CONFIGS: Record<string, string> = {
-  zsh: '.zshrc',
-  bash: '.bashrc',
-  fish: '.config/fish/config.fish',
-};
-
-export const VERSION = '0.0.1';

package/src/core/emitter.ts

@@ -1,48 +0,0 @@
-import type { CoreEvent, EventData } from '@/core/types';
-
-type EventHandler = (event: CoreEvent) => void;
-
-class OperationEmitter {
-  private handlers = new Map<string, Set<EventHandler>>();
-  private globalHandlers = new Set<EventHandler>();
-
-  subscribe(operationId: string, handler: EventHandler): () => void {
-    if (!this.handlers.has(operationId)) {
-      this.handlers.set(operationId, new Set());
-    }
-    this.handlers.get(operationId)!.add(handler);
-
-    return () => {
-      this.handlers.get(operationId)?.delete(handler);
-    };
-  }
-
-  subscribeAll(handler: EventHandler): () => void {
-    this.globalHandlers.add(handler);
-    return () => {
-      this.globalHandlers.delete(handler);
-    };
-  }
-
-  emit(operationId: string, data: EventData): void {
-    const event: CoreEvent = {
-      type: data.type,
-      timestamp: Date.now(),
-      operationId,
-      data,
-    };
-
-    this.handlers.get(operationId)?.forEach((h) => h(event));
-    this.globalHandlers.forEach((h) => h(event));
-  }
-
-  cleanup(operationId: string): void {
-    this.handlers.delete(operationId);
-  }
-}
-
-export const emitter = new OperationEmitter();
-
-export function createOperationId(): string {
-  return `op_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-}

package/src/core/operations/build.ts

@@ -1,70 +0,0 @@
-import type { BuildConfig, Result } from '@/core/types';
-import { emitter, createOperationId } from '@/core/emitter';
-import { runWithIdf } from '@/core/services/process';
-import { isIdfProject } from '@/core/services/idf';
-
-export interface BuildResult {
-  success: boolean;
-  projectDir: string;
-}
-
-export async function build(
-  config: BuildConfig,
-  operationId?: string
-): Promise<Result<BuildResult>> {
-  const opId = operationId || createOperationId();
-  const { projectDir, target, clean } = config;
-
-  const isProject = await isIdfProject(projectDir);
-  if (!isProject) {
-    const error = 'Not an ESP-IDF project directory';
-    emitter.emit(opId, { type: 'error', message: error });
-    return { ok: false, error };
-  }
-
-  if (target) {
-    emitter.emit(opId, { type: 'progress', message: `Setting target to ${target}...` });
-
-    const targetResult = await runWithIdf('idf.py', ['set-target', target], {
-      cwd: projectDir,
-      operationId: opId,
-    });
-
-    if (!targetResult.ok || targetResult.data.exitCode !== 0) {
-      const error = 'Failed to set target';
-      emitter.emit(opId, { type: 'error', message: error });
-      return { ok: false, error };
-    }
-  }
-
-  if (clean) {
-    emitter.emit(opId, { type: 'progress', message: 'Cleaning...' });
-
-    await runWithIdf('idf.py', ['clean'], {
-      cwd: projectDir,
-      operationId: opId,
-    });
-  }
-
-  emitter.emit(opId, { type: 'progress', message: 'Building project...' });
-
-  const buildResult = await runWithIdf('idf.py', ['build'], {
-    cwd: projectDir,
-    operationId: opId,
-  });
-
-  if (!buildResult.ok) {
-    emitter.emit(opId, { type: 'error', message: buildResult.error });
-    return { ok: false, error: buildResult.error };
-  }
-
-  if (buildResult.data.exitCode !== 0) {
-    const error = 'Build failed';
-    emitter.emit(opId, { type: 'error', message: error });
-    return { ok: false, error };
-  }
-
-  emitter.emit(opId, { type: 'complete', result: { success: true, projectDir } });
-
-  return { ok: true, data: { success: true, projectDir } };
-}

package/src/core/operations/clean.ts

@@ -1,42 +0,0 @@
-import type { CleanConfig, Result } from '@/core/types';
-import { emitter, createOperationId } from '@/core/emitter';
-import { runWithIdf } from '@/core/services/process';
-import { isIdfProject } from '@/core/services/idf';
-
-export async function clean(
-  config: CleanConfig,
-  operationId?: string
-): Promise<Result<void>> {
-  const opId = operationId || createOperationId();
-  const { projectDir, full } = config;
-
-  const isProject = await isIdfProject(projectDir);
-  if (!isProject) {
-    const error = 'Not an ESP-IDF project directory';
-    emitter.emit(opId, { type: 'error', message: error });
-    return { ok: false, error };
-  }
-
-  const command = full ? 'fullclean' : 'clean';
-  emitter.emit(opId, { type: 'progress', message: `Running ${command}...` });
-
-  const result = await runWithIdf('idf.py', [command], {
-    cwd: projectDir,
-    operationId: opId,
-  });
-
-  if (!result.ok) {
-    emitter.emit(opId, { type: 'error', message: result.error });
-    return { ok: false, error: result.error };
-  }
-
-  if (result.data.exitCode !== 0) {
-    const error = `${command} failed`;
-    emitter.emit(opId, { type: 'error', message: error });
-    return { ok: false, error };
-  }
-
-  emitter.emit(opId, { type: 'complete', result: null });
-
-  return { ok: true, data: undefined };
-}

package/src/core/operations/devices.ts

@@ -1,11 +0,0 @@
-import type { SerialDevice, Result } from '@/core/types';
-import { listPorts } from '@/core/services/ports';
-
-export async function listDevices(): Promise<Result<SerialDevice[]>> {
-  try {
-    const devices = await listPorts();
-    return { ok: true, data: devices };
-  } catch (err) {
-    return { ok: false, error: `Failed to list devices: ${err}` };
-  }
-}

package/src/core/operations/flash.ts

@@ -1,49 +0,0 @@
-import type { FlashConfig, Result } from '@/core/types';
-import { emitter, createOperationId } from '@/core/emitter';
-import { runWithIdf } from '@/core/services/process';
-import { isIdfProject } from '@/core/services/idf';
-import { DEFAULT_FLASH_BAUD } from '@/core/constants';
-
-export interface FlashResult {
-  success: boolean;
-  port: string;
-}
-
-export async function flash(
-  config: FlashConfig,
-  operationId?: string
-): Promise<Result<FlashResult>> {
-  const opId = operationId || createOperationId();
-  const { projectDir, port, baud = DEFAULT_FLASH_BAUD } = config;
-
-  const isProject = await isIdfProject(projectDir);
-  if (!isProject) {
-    const error = 'Not an ESP-IDF project directory';
-    emitter.emit(opId, { type: 'error', message: error });
-    return { ok: false, error };
-  }
-
-  emitter.emit(opId, { type: 'progress', message: `Flashing to ${port}...` });
-
-  const args = ['-p', port, '-b', String(baud), 'flash'];
-
-  const flashResult = await runWithIdf('idf.py', args, {
-    cwd: projectDir,
-    operationId: opId,
-  });
-
-  if (!flashResult.ok) {
-    emitter.emit(opId, { type: 'error', message: flashResult.error });
-    return { ok: false, error: flashResult.error };
-  }
-
-  if (flashResult.data.exitCode !== 0) {
-    const error = 'Flash failed';
-    emitter.emit(opId, { type: 'error', message: error });
-    return { ok: false, error };
-  }
-
-  emitter.emit(opId, { type: 'complete', result: { success: true, port } });
-
-  return { ok: true, data: { success: true, port } };
-}

package/src/core/operations/init.ts

@@ -1,39 +0,0 @@
-import type { InitConfig, InitResult, Result } from '@/core/types';
-import { createProject } from '@/core/templates';
-import { emitter, createOperationId } from '@/core/emitter';
-import { runWithIdf } from '@/core/services/process';
-
-export async function init(
-  config: InitConfig,
-  operationId?: string
-): Promise<Result<InitResult>> {
-  const opId = operationId || createOperationId();
-
-  emitter.emit(opId, { type: 'progress', message: `Creating project ${config.name}...` });
-
-  const result = await createProject(config);
-
-  if (!result.ok) {
-    emitter.emit(opId, { type: 'error', message: result.error });
-    return result;
-  }
-
-  emitter.emit(opId, { type: 'progress', message: 'Setting target...', percent: 80 });
-
-  const setTargetResult = await runWithIdf('idf.py', ['set-target', config.target], {
-    cwd: result.data.projectPath,
-    operationId: opId,
-  });
-
-  if (!setTargetResult.ok || setTargetResult.data.exitCode !== 0) {
-    emitter.emit(opId, {
-      type: 'log',
-      level: 'warn',
-      message: 'Failed to set target. You may need to run: idf.py set-target ' + config.target,
-    });
-  }
-
-  emitter.emit(opId, { type: 'complete', result: result.data });
-
-  return result;
-}

package/src/core/operations/install.ts

@@ -1,99 +0,0 @@
-import type { InstallConfig, InstallResult, Result } from '@/core/types';
-import { emitter, createOperationId } from '@/core/emitter';
-import { DEFAULT_ESP_PATH, IDF_REPO_URL } from '@/core/constants';
-import { run } from '@/core/services/process';
-import { addToShellConfig, getExportCommand } from '@/core/services/shell';
-import { getIdfVersion } from '@/core/services/idf';
-import { mkdir, access } from 'fs/promises';
-import { join } from 'path';
-
-export async function install(
-  config: Partial<InstallConfig> = {},
-  operationId?: string
-): Promise<Result<InstallResult>> {
-  const opId = operationId || createOperationId();
-  const espPath = config.path || DEFAULT_ESP_PATH;
-  const target = config.target || 'all';
-  const addToShell = config.addToShell ?? true;
-  const idfPath = join(espPath, 'esp-idf');
-
-  try {
-    await access(idfPath);
-    const version = await getIdfVersion(idfPath);
-    emitter.emit(opId, { type: 'log', level: 'info', message: `ESP-IDF already installed at ${idfPath}` });
-    return {
-      ok: true,
-      data: {
-        idfPath,
-        version: version || 'unknown',
-        addedToShell: false,
-      },
-    };
-  } catch {}
-
-  emitter.emit(opId, { type: 'progress', message: 'Creating ESP directory...' });
-
-  try {
-    await mkdir(espPath, { recursive: true });
-  } catch (err) {
-    return { ok: false, error: `Failed to create directory: ${err}` };
-  }
-
-  emitter.emit(opId, { type: 'progress', message: 'Cloning ESP-IDF repository...', percent: 10 });
-
-  const cloneResult = await run('git', ['clone', '--recursive', IDF_REPO_URL], {
-    cwd: espPath,
-    operationId: opId,
-  });
-
-  if (!cloneResult.ok) {
-    return { ok: false, error: cloneResult.error };
-  }
-
-  if (cloneResult.data.exitCode !== 0) {
-    return { ok: false, error: `Git clone failed with exit code ${cloneResult.data.exitCode}` };
-  }
-
-  emitter.emit(opId, { type: 'progress', message: 'Running install script...', percent: 50 });
-
-  const installArgs = target === 'all' ? ['all'] : [target];
-  const installResult = await run('./install.sh', installArgs, {
-    cwd: idfPath,
-    operationId: opId,
-  });
-
-  if (!installResult.ok) {
-    return { ok: false, error: installResult.error };
-  }
-
-  if (installResult.data.exitCode !== 0) {
-    return { ok: false, error: `Install script failed with exit code ${installResult.data.exitCode}` };
-  }
-
-  let addedToShell = false;
-
-  if (addToShell) {
-    emitter.emit(opId, { type: 'progress', message: 'Configuring shell...', percent: 90 });
-    const exportCmd = getExportCommand(idfPath);
-    const shellResult = await addToShellConfig(exportCmd);
-
-    if (shellResult.ok) {
-      addedToShell = true;
-    } else {
-      emitter.emit(opId, { type: 'log', level: 'warn', message: shellResult.error });
-    }
-  }
-
-  const version = await getIdfVersion(idfPath);
-
-  emitter.emit(opId, { type: 'complete', result: { idfPath, version, addedToShell } });
-
-  return {
-    ok: true,
-    data: {
-      idfPath,
-      version: version || 'unknown',
-      addedToShell,
-    },
-  };
-}

package/src/core/operations/monitor.ts

@@ -1,67 +0,0 @@
-import type { MonitorConfig, Result } from '@/core/types';
-import { emitter, createOperationId } from '@/core/emitter';
-import { spawnWithIdf } from '@/core/services/process';
-import { DEFAULT_MONITOR_BAUD } from '@/core/constants';
-import type { ResultPromise } from 'execa';
-
-const activeMonitors = new Map<string, ResultPromise>();
-
-export interface MonitorHandle {
-  operationId: string;
-  stop: () => void;
-  sendInput: (data: string) => void;
-}
-
-export function startMonitor(
-  config: MonitorConfig,
-  operationId?: string
-): Result<MonitorHandle> {
-  const opId = operationId || createOperationId();
-  const { port, baud = DEFAULT_MONITOR_BAUD, projectDir } = config;
-
-  const args = ['-p', port, '-b', String(baud), 'monitor'];
-
-  const proc = spawnWithIdf('idf.py', args, {
-    cwd: projectDir || process.cwd(),
-    operationId: opId,
-  });
-
-  if (!proc) {
-    const error = 'ESP-IDF not found';
-    emitter.emit(opId, { type: 'error', message: error });
-    return { ok: false, error };
-  }
-
-  activeMonitors.set(opId, proc);
-
-  proc.then(() => {
-    activeMonitors.delete(opId);
-    emitter.emit(opId, { type: 'complete', result: { stopped: true } });
-  });
-
-  const handle: MonitorHandle = {
-    operationId: opId,
-    stop: () => {
-      proc.kill('SIGTERM');
-      activeMonitors.delete(opId);
-    },
-    sendInput: (data: string) => {
-      proc.stdin?.write(data);
-    },
-  };
-
-  return { ok: true, data: handle };
-}
-
-export function stopMonitor(operationId: string): boolean {
-  const proc = activeMonitors.get(operationId);
-  if (!proc) return false;
-
-  proc.kill('SIGTERM');
-  activeMonitors.delete(operationId);
-  return true;
-}
-
-export function getActiveMonitors(): string[] {
-  return Array.from(activeMonitors.keys());
-}