espcli 0.0.1 → 0.0.2

package/src/core/templates/files.ts

@@ -1,78 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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

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

package/src/serve.ts

@@ -1,8 +0,0 @@
-#!/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

@@ -1,105 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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');
-}