espcli 0.0.1

package/src/core/templates/files.ts

@@ -0,0 +1,78 @@
+export function getRootCMakeLists(projectName: string): string {
+  return `cmake_minimum_required(VERSION 3.16)
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(${projectName})
+`;
+}
+
+export function getMainCMakeLists(mainFile: string): string {
+  return `idf_component_register(SRCS "${mainFile}"
+                       INCLUDE_DIRS ".")
+`;
+}
+
+export function getCMain(projectName: string): string {
+  return `#include <stdio.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+void app_main(void)
+{
+    while (1) {
+        printf("Hello from ${projectName}!\\n");
+        vTaskDelay(pdMS_TO_TICKS(1000));
+    }
+}
+`;
+}
+
+export function getCppMain(projectName: string): string {
+  return `#include <cstdio>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+extern "C" void app_main(void)
+{
+    while (true) {
+        printf("Hello from ${projectName}!\\n");
+        vTaskDelay(pdMS_TO_TICKS(1000));
+    }
+}
+`;
+}
+
+export function getGitignore(): string {
+  return `build/
+sdkconfig
+sdkconfig.old
+.vscode/
+*.pyc
+__pycache__/
+.DS_Store
+`;
+}
+
+export function getReadme(projectName: string, target: string): string {
+  return `# ${projectName}
+
+ESP-IDF project targeting ${target}.
+
+## Build
+
+\`\`\`bash
+idf.py build
+\`\`\`
+
+## Flash
+
+\`\`\`bash
+idf.py -p PORT flash
+\`\`\`
+
+## Monitor
+
+\`\`\`bash
+idf.py -p PORT monitor
+\`\`\`
+`;
+}

package/src/core/templates/index.ts

@@ -0,0 +1,52 @@
+import type { InitConfig, InitResult, Result, TemplateFile } from '@/core/types';
+import { mkdir, writeFile } from 'fs/promises';
+import { join } from 'path';
+import {
+  getRootCMakeLists,
+  getMainCMakeLists,
+  getCMain,
+  getCppMain,
+  getGitignore,
+  getReadme,
+} from '@/core/templates/files';
+
+export function generateProjectFiles(config: InitConfig): TemplateFile[] {
+  const { name, language, target } = config;
+  const mainFile = language === 'cpp' ? 'main.cpp' : 'main.c';
+  const mainContent = language === 'cpp' ? getCppMain(name) : getCMain(name);
+
+  return [
+    { path: 'CMakeLists.txt', content: getRootCMakeLists(name) },
+    { path: 'main/CMakeLists.txt', content: getMainCMakeLists(mainFile) },
+    { path: `main/${mainFile}`, content: mainContent },
+    { path: '.gitignore', content: getGitignore() },
+    { path: 'README.md', content: getReadme(name, target) },
+  ];
+}
+
+export async function createProject(config: InitConfig): Promise<Result<InitResult>> {
+  const projectPath = join(config.directory, config.name);
+  const files = generateProjectFiles(config);
+
+  try {
+    await mkdir(join(projectPath, 'main'), { recursive: true });
+
+    const createdFiles: string[] = [];
+
+    for (const file of files) {
+      const filePath = join(projectPath, file.path);
+      await writeFile(filePath, file.content);
+      createdFiles.push(file.path);
+    }
+
+    return {
+      ok: true,
+      data: {
+        projectPath,
+        files: createdFiles,
+      },
+    };
+  } catch (err) {
+    return { ok: false, error: `Failed to create project: ${err}` };
+  }
+}

package/src/core/types.ts

@@ -0,0 +1,128 @@
+export type Result<T> =
+  | { ok: true; data: T }
+  | { ok: false; error: string; code?: string };
+
+export type ShellType = 'zsh' | 'bash' | 'fish' | 'unknown';
+
+export interface ShellInfo {
+  type: ShellType;
+  configPath: string;
+}
+
+export interface EspTarget {
+  id: string;
+  name: string;
+  description: string;
+  stable: boolean;
+}
+
+export type ConnectionType = 'native-usb' | 'uart-bridge' | 'unknown';
+
+export interface SerialDevice {
+  port: string;
+  vendorId?: string;
+  productId?: string;
+  manufacturer?: string;
+  chip?: string;
+  connectionType: ConnectionType;
+  espChip?: string; // Actual ESP chip detected via esptool (e.g., "ESP32-S3")
+  description?: string; // USB device description (e.g., "USB JTAG/serial debug unit")
+}
+
+export interface IdfStatus {
+  installed: boolean;
+  path?: string;
+  version?: string;
+}
+
+export interface InstallConfig {
+  path: string;
+  target: string;
+  addToShell: boolean;
+}
+
+export interface InstallResult {
+  idfPath: string;
+  version: string;
+  addedToShell: boolean;
+}
+
+export interface InitConfig {
+  name: string;
+  directory: string;
+  language: 'c' | 'cpp';
+  target: string;
+}
+
+export interface InitResult {
+  projectPath: string;
+  files: string[];
+}
+
+export interface BuildConfig {
+  projectDir: string;
+  target?: string;
+  clean?: boolean;
+}
+
+export interface FlashConfig {
+  projectDir: string;
+  port: string;
+  baud?: number;
+}
+
+export interface MonitorConfig {
+  port: string;
+  baud?: number;
+  projectDir?: string;
+}
+
+export interface CleanConfig {
+  projectDir: string;
+  full?: boolean;
+}
+
+export type EventType =
+  | 'progress'
+  | 'log'
+  | 'stdout'
+  | 'stderr'
+  | 'complete'
+  | 'error';
+
+export type LogLevel = 'info' | 'warn' | 'error';
+
+export type EventData =
+  | { type: 'progress'; message: string; percent?: number }
+  | { type: 'log'; level: LogLevel; message: string }
+  | { type: 'stdout'; text: string }
+  | { type: 'stderr'; text: string }
+  | { type: 'complete'; result: unknown }
+  | { type: 'error'; message: string; code?: string };
+
+export interface CoreEvent {
+  type: EventType;
+  timestamp: number;
+  operationId: string;
+  data: EventData;
+}
+
+export interface TemplateFile {
+  path: string;
+  content: string;
+}
+
+export interface ProjectTemplate {
+  language: 'c' | 'cpp';
+  files: TemplateFile[];
+}
+
+export type WsClientMessage =
+  | { type: 'subscribe'; operationId: string }
+  | { type: 'unsubscribe'; operationId: string }
+  | { type: 'input'; operationId: string; data: string };
+
+export type WsServerMessage =
+  | { type: 'event'; operationId: string; event: CoreEvent }
+  | { type: 'subscribed'; operationId: string }
+  | { type: 'error'; message: string };

package/src/index.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+import { createCli } from '@/tui';
+
+const cli = createCli();
+cli.parse();

package/src/serve.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env bun
+import { createServer } from '@/server';
+
+const port = parseInt(process.env.PORT || '3000', 10);
+const server = createServer(port);
+
+console.log(`ESP CLI server running on http://localhost:${server.port}`);
+console.log(`WebSocket available at ws://localhost:${server.port}/ws`);

package/src/server/index.ts

@@ -0,0 +1,105 @@
+import type { ServerWebSocket } from 'bun';
+import { matchRoute } from '@/server/routes';
+import { emitter } from '@/core/emitter';
+import type { WsClientMessage, WsServerMessage, CoreEvent } from '@/core/types';
+
+interface WsData {
+  subscriptions: Set<string>;
+}
+
+const clients = new Set<ServerWebSocket<WsData>>();
+
+function broadcast(operationId: string, event: CoreEvent): void {
+  const message: WsServerMessage = { type: 'event', operationId, event };
+  const payload = JSON.stringify(message);
+
+  for (const ws of clients) {
+    if (ws.data.subscriptions.has(operationId)) {
+      ws.send(payload);
+    }
+  }
+}
+
+emitter.subscribeAll((event) => {
+  broadcast(event.operationId, event);
+});
+
+function corsHeaders(): HeadersInit {
+  return {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type',
+  };
+}
+
+function withCors(response: Response): Response {
+  const headers = new Headers(response.headers);
+  Object.entries(corsHeaders()).forEach(([key, value]) => {
+    headers.set(key, value);
+  });
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}
+
+export function createServer(port: number) {
+  return Bun.serve<WsData>({
+    port,
+    async fetch(req, server) {
+      const url = new URL(req.url);
+
+      // Handle CORS preflight
+      if (req.method === 'OPTIONS') {
+        return new Response(null, { headers: corsHeaders() });
+      }
+
+      if (url.pathname === '/ws') {
+        const upgraded = server.upgrade(req, {
+          data: { subscriptions: new Set<string>() },
+        });
+        if (upgraded) return undefined;
+        return new Response('WebSocket upgrade failed', { status: 400 });
+      }
+
+      const handler = matchRoute(req.method, url.pathname);
+
+      if (handler) {
+        const response = await handler(req);
+        return withCors(response);
+      }
+
+      return withCors(new Response('Not Found', { status: 404 }));
+    },
+    websocket: {
+      open(ws) {
+        clients.add(ws);
+      },
+      close(ws) {
+        clients.delete(ws);
+      },
+      message(ws, message) {
+        try {
+          const data = JSON.parse(message.toString()) as WsClientMessage;
+
+          switch (data.type) {
+            case 'subscribe':
+              ws.data.subscriptions.add(data.operationId);
+              ws.send(JSON.stringify({ type: 'subscribed', operationId: data.operationId }));
+              break;
+
+            case 'unsubscribe':
+              ws.data.subscriptions.delete(data.operationId);
+              break;
+
+            case 'input':
+              break;
+          }
+        } catch {
+          ws.send(JSON.stringify({ type: 'error', message: 'Invalid message format' }));
+        }
+      },
+    },
+  });
+}

package/src/server/routes.ts

@@ -0,0 +1,175 @@
+import { VERSION, ESP_TARGETS } from '@/core/constants';
+import { getIdfStatus } from '@/core/services/idf';
+import { listDevices } from '@/core/operations/devices';
+import { install } from '@/core/operations/install';
+import { init } from '@/core/operations/init';
+import { build } from '@/core/operations/build';
+import { flash } from '@/core/operations/flash';
+import { startMonitor, stopMonitor } from '@/core/operations/monitor';
+import { clean } from '@/core/operations/clean';
+import { createOperationId } from '@/core/emitter';
+import type {
+  HealthResponse,
+  TargetsResponse,
+  DevicesResponse,
+  InstallRequest,
+  InitRequest,
+  BuildRequest,
+  FlashRequest,
+  MonitorRequest,
+  MonitorStopRequest,
+  CleanRequest,
+} from '@/server/schema';
+
+type RouteHandler = (req: Request) => Promise<Response>;
+
+function json<T>(data: T, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+function error(message: string, status = 400): Response {
+  return json({ error: message }, status);
+}
+
+async function parseBody<T>(req: Request): Promise<T | null> {
+  try {
+    return (await req.json()) as T;
+  } catch {
+    return null;
+  }
+}
+
+export const routes: Record<string, RouteHandler> = {
+  'GET /api/health': async () => {
+    const response: HealthResponse = { status: 'ok', version: VERSION };
+    return json(response);
+  },
+
+  'GET /api/targets': async () => {
+    const response: TargetsResponse = { targets: ESP_TARGETS };
+    return json(response);
+  },
+
+  'GET /api/devices': async () => {
+    const result = await listDevices();
+    if (!result.ok) {
+      return error(result.error, 500);
+    }
+    const response: DevicesResponse = { devices: result.data };
+    return json(response);
+  },
+
+  'GET /api/idf/status': async () => {
+    const status = await getIdfStatus();
+    return json(status);
+  },
+
+  'POST /api/install': async (req) => {
+    const body = await parseBody<InstallRequest>(req);
+    const operationId = createOperationId();
+
+    install(
+      {
+        path: body?.path || '',
+        target: body?.target || 'all',
+        addToShell: body?.addToShell ?? true,
+      },
+      operationId
+    );
+
+    return json({ operationId });
+  },
+
+  'POST /api/init': async (req) => {
+    const body = await parseBody<InitRequest>(req);
+
+    if (!body?.name || !body.directory || !body.language || !body.target) {
+      return error('Missing required fields: name, directory, language, target');
+    }
+
+    const result = await init(body);
+
+    if (!result.ok) {
+      return json({ ok: false, error: result.error });
+    }
+
+    return json({ ok: true, projectPath: result.data.projectPath });
+  },
+
+  'POST /api/build': async (req) => {
+    const body = await parseBody<BuildRequest>(req);
+
+    if (!body?.projectDir) {
+      return error('Missing required field: projectDir');
+    }
+
+    const operationId = createOperationId();
+
+    build(body, operationId);
+
+    return json({ operationId });
+  },
+
+  'POST /api/flash': async (req) => {
+    const body = await parseBody<FlashRequest>(req);
+
+    if (!body?.projectDir || !body.port) {
+      return error('Missing required fields: projectDir, port');
+    }
+
+    const operationId = createOperationId();
+
+    flash(body, operationId);
+
+    return json({ operationId });
+  },
+
+  'POST /api/monitor': async (req) => {
+    const body = await parseBody<MonitorRequest>(req);
+
+    if (!body?.port) {
+      return error('Missing required field: port');
+    }
+
+    const operationId = createOperationId();
+    const result = startMonitor(body, operationId);
+
+    if (!result.ok) {
+      return error(result.error, 500);
+    }
+
+    return json({ operationId });
+  },
+
+  'POST /api/monitor/stop': async (req) => {
+    const body = await parseBody<MonitorStopRequest>(req);
+
+    if (!body?.operationId) {
+      return error('Missing required field: operationId');
+    }
+
+    const stopped = stopMonitor(body.operationId);
+
+    return json({ ok: stopped });
+  },
+
+  'POST /api/clean': async (req) => {
+    const body = await parseBody<CleanRequest>(req);
+
+    if (!body?.projectDir) {
+      return error('Missing required field: projectDir');
+    }
+
+    const result = await clean(body);
+
+    return json({ ok: result.ok, error: result.ok ? undefined : result.error });
+  },
+};
+
+export function matchRoute(method: string, path: string): RouteHandler | null {
+  const key = `${method} ${path}`;
+  return routes[key] || null;
+}

package/src/server/schema.ts

@@ -0,0 +1,81 @@
+import type { EspTarget, SerialDevice, IdfStatus, CoreEvent } from '@/core/types';
+
+export interface HealthResponse {
+  status: 'ok';
+  version: string;
+}
+
+export interface TargetsResponse {
+  targets: EspTarget[];
+}
+
+export interface DevicesResponse {
+  devices: SerialDevice[];
+}
+
+export interface IdfStatusResponse extends IdfStatus {}
+
+export interface InstallRequest {
+  path?: string;
+  target?: string;
+  addToShell?: boolean;
+}
+
+export interface OperationResponse {
+  operationId: string;
+}
+
+export interface InitRequest {
+  name: string;
+  directory: string;
+  language: 'c' | 'cpp';
+  target: string;
+}
+
+export interface InitResponse {
+  ok: boolean;
+  projectPath?: string;
+  error?: string;
+}
+
+export interface BuildRequest {
+  projectDir: string;
+  target?: string;
+  clean?: boolean;
+}
+
+export interface FlashRequest {
+  projectDir: string;
+  port: string;
+  baud?: number;
+}
+
+export interface MonitorRequest {
+  port: string;
+  baud?: number;
+  projectDir?: string;
+}
+
+export interface MonitorStopRequest {
+  operationId: string;
+}
+
+export interface CleanRequest {
+  projectDir: string;
+  full?: boolean;
+}
+
+export interface CleanResponse {
+  ok: boolean;
+  error?: string;
+}
+
+export type WsClientMessage =
+  | { type: 'subscribe'; operationId: string }
+  | { type: 'unsubscribe'; operationId: string }
+  | { type: 'input'; operationId: string; data: string };
+
+export type WsServerMessage =
+  | { type: 'event'; operationId: string; event: CoreEvent }
+  | { type: 'subscribed'; operationId: string }
+  | { type: 'error'; message: string };

package/src/tui/commands/build.ts

@@ -0,0 +1,48 @@
+import { build } from '@/core/operations/build';
+import { findProjectRoot } from '@/core/services/idf';
+import { emitter, createOperationId } from '@/core/emitter';
+import { logger } from '@/tui/logger';
+
+interface BuildOptions {
+  target?: string;
+  clean?: boolean;
+}
+
+export async function buildCommand(options: BuildOptions): Promise<void> {
+  const projectDir = await findProjectRoot(process.cwd());
+
+  if (!projectDir) {
+    logger.error('Not in an ESP-IDF project directory');
+    process.exit(1);
+  }
+
+  const opId = createOperationId();
+
+  emitter.subscribe(opId, (event) => {
+    if (event.data.type === 'stdout') {
+      logger.output(event.data.text);
+    } else if (event.data.type === 'stderr') {
+      logger.output(event.data.text);
+    }
+  });
+
+  logger.step('Building project...');
+
+  const result = await build(
+    {
+      projectDir,
+      target: options.target,
+      clean: options.clean,
+    },
+    opId
+  );
+
+  if (!result.ok) {
+    logger.newline();
+    logger.error(result.error);
+    process.exit(1);
+  }
+
+  logger.newline();
+  logger.success('Build complete');
+}