crosspad-mcp-server 4.0.0

package/src/tools/idf-build.ts

@@ -0,0 +1,182 @@
+import fs from "fs";
+import path from "path";
+import { CROSSPAD_IDF_ROOT } from "../config.js";
+import { runWithIdf, runWithIdfStream, OnLine } from "../utils/exec.js";
+
+export interface IdfBuildResult {
+  success: boolean;
+  duration_seconds: number;
+  errors: string[];
+  warnings: string[];
+  tail: string[];
+  auto_reconfigured?: boolean;
+}
+
+/**
+ * Detect app directories that have REGISTER_APP in their sources but are NOT
+ * listed in the auto-generated app_registry_init.cpp. This means CMake hasn't
+ * seen them yet (file(GLOB) only runs at configure time).
+ */
+function detectUnregisteredApps(): string[] {
+  const appsDir = path.join(CROSSPAD_IDF_ROOT, "main", "app");
+  const registryFile = path.join(appsDir, "app_registry_init.cpp");
+
+  if (!fs.existsSync(registryFile)) return [];
+
+  const registryContent = fs.readFileSync(registryFile, "utf-8");
+
+  const unregistered: string[] = [];
+
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(appsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const appCmake = path.join(appsDir, entry.name, "CMakeLists.txt");
+    if (!fs.existsSync(appCmake)) continue;
+
+    // Scan .cpp files in this app dir for REGISTER_APP
+    const appDir = path.join(appsDir, entry.name);
+    let hasRegisterApp = false;
+    let appName = "";
+
+    try {
+      for (const file of fs.readdirSync(appDir)) {
+        if (!file.endsWith(".cpp")) continue;
+        const content = fs.readFileSync(path.join(appDir, file), "utf-8");
+        const match = content.match(/REGISTER_APP\((\w+)/);
+        if (match) {
+          hasRegisterApp = true;
+          appName = match[1];
+          break;
+        }
+      }
+    } catch {
+      continue;
+    }
+
+    if (hasRegisterApp && appName) {
+      // Check if this app is in the registry
+      const registerFn = `_register_${appName}_app`;
+      if (!registryContent.includes(registerFn)) {
+        unregistered.push(appName);
+      }
+    }
+  }
+
+  return unregistered;
+}
+
+function parseErrors(output: string): string[] {
+  const errors: string[] = [];
+  for (const line of output.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (/:\d+:\d+: (?:fatal )?error:/.test(trimmed)) {
+      errors.push(trimmed);
+    } else if (/^.*ld.*: error:/.test(trimmed) || /undefined reference to/.test(trimmed)) {
+      errors.push(trimmed);
+    } else if (/^CMake Error/i.test(trimmed)) {
+      errors.push(trimmed);
+    } else if (/FAILED:/.test(trimmed) && !trimmed.startsWith("[")) {
+      errors.push(trimmed);
+    }
+  }
+  return errors.slice(0, 30);
+}
+
+function parseWarnings(output: string): string[] {
+  const warnings: string[] = [];
+  for (const line of output.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (/:\d+:\d+: warning:/.test(trimmed)) {
+      warnings.push(trimmed);
+    }
+  }
+  return warnings.slice(0, 20);
+}
+
+function getTail(output: string, n: number): string[] {
+  return output.split("\n").filter(l => l.trim()).slice(-n);
+}
+
+async function runIdfCmd(
+  cmd: string,
+  onLine: OnLine | undefined,
+  timeoutMs: number,
+): Promise<{ stdout: string; stderr: string; success: boolean }> {
+  if (onLine) {
+    const r = await runWithIdfStream(cmd, CROSSPAD_IDF_ROOT, onLine, timeoutMs);
+    return r;
+  }
+  return runWithIdf(cmd, CROSSPAD_IDF_ROOT, timeoutMs);
+}
+
+export async function crosspadIdfBuild(
+  mode: "build" | "fullclean" | "clean",
+  onLine?: OnLine
+): Promise<IdfBuildResult> {
+  const startTime = Date.now();
+  let autoReconfigured = false;
+
+  // Auto-detect unregistered apps — if found, escalate to fullclean
+  if (mode === "build") {
+    const unregistered = detectUnregisteredApps();
+    if (unregistered.length > 0) {
+      onLine?.("stdout", `[idf] Detected ${unregistered.length} unregistered app(s): ${unregistered.join(", ")} — running fullclean`);
+      mode = "fullclean";
+      autoReconfigured = true;
+    }
+  }
+
+  if (mode === "fullclean") {
+    onLine?.("stdout", "[idf] Running idf.py fullclean...");
+    const r = await runIdfCmd("idf.py fullclean", onLine, 60_000);
+    if (!r.success) {
+      const combined = r.stdout + "\n" + r.stderr;
+      return {
+        success: false,
+        duration_seconds: (Date.now() - startTime) / 1000,
+        errors: parseErrors(combined),
+        warnings: [],
+        tail: getTail(combined, 20),
+        auto_reconfigured: autoReconfigured,
+      };
+    }
+  }
+
+  if (mode === "clean") {
+    const buildDir = path.join(CROSSPAD_IDF_ROOT, "build");
+    if (fs.existsSync(buildDir)) {
+      onLine?.("stdout", "[idf] Removing build directory...");
+      fs.rmSync(buildDir, { recursive: true, force: true });
+    }
+  }
+
+  onLine?.("stdout", "[idf] Building...");
+
+  const r = await runIdfCmd("idf.py build", onLine, 600_000);
+  const combined = r.stdout + "\n" + r.stderr;
+  const errors = parseErrors(combined);
+  const warnings = parseWarnings(combined);
+
+  const result: IdfBuildResult = {
+    success: r.success,
+    duration_seconds: (Date.now() - startTime) / 1000,
+    errors,
+    warnings,
+    tail: getTail(combined, r.success ? 10 : 30),
+  };
+
+  if (autoReconfigured) {
+    result.auto_reconfigured = true;
+  }
+
+  onLine?.("stdout", `[idf] Build ${result.success ? "succeeded" : "FAILED"} in ${result.duration_seconds.toFixed(1)}s`);
+  return result;
+}

package/src/tools/input.ts

@@ -0,0 +1,80 @@
+/**
+ * MCP tool: send input events to the running CrossPad simulator.
+ * Supports: click, pad_press/release, encoder_rotate/press/release, key.
+ */
+
+import { sendRemoteCommand, isSimulatorRunning, RemoteResponse } from "../utils/remote-client.js";
+
+export type InputAction =
+  | { action: "click"; x: number; y: number }
+  | { action: "pad_press"; pad: number; velocity?: number }
+  | { action: "pad_release"; pad: number }
+  | { action: "encoder_rotate"; delta: number }
+  | { action: "encoder_press" }
+  | { action: "encoder_release" }
+  | { action: "key"; keycode: number };
+
+export interface InputResult {
+  success: boolean;
+  action: string;
+  response?: Record<string, unknown>;
+  error?: string;
+}
+
+/**
+ * Send a single input event to the simulator.
+ */
+export async function crosspadInput(input: InputAction): Promise<InputResult> {
+  const running = await isSimulatorRunning();
+  if (!running) {
+    return {
+      success: false,
+      action: input.action,
+      error: "Simulator is not running. Use crosspad_run to start it.",
+    };
+  }
+
+  try {
+    let cmd: Record<string, unknown>;
+
+    switch (input.action) {
+      case "click":
+        cmd = { cmd: "click", x: input.x, y: input.y };
+        break;
+      case "pad_press":
+        cmd = { cmd: "pad_press", pad: input.pad, velocity: input.velocity ?? 127 };
+        break;
+      case "pad_release":
+        cmd = { cmd: "pad_release", pad: input.pad };
+        break;
+      case "encoder_rotate":
+        cmd = { cmd: "encoder_rotate", delta: input.delta };
+        break;
+      case "encoder_press":
+        cmd = { cmd: "encoder_press" };
+        break;
+      case "encoder_release":
+        cmd = { cmd: "encoder_release" };
+        break;
+      case "key":
+        cmd = { cmd: "key", keycode: input.keycode };
+        break;
+      default:
+        return { success: false, action: "unknown", error: "Unknown action" };
+    }
+
+    const resp = await sendRemoteCommand(cmd);
+    return {
+      success: resp.ok === true,
+      action: input.action,
+      response: resp as Record<string, unknown>,
+      error: resp.ok ? undefined : (resp.error as string),
+    };
+  } catch (err: any) {
+    return {
+      success: false,
+      action: input.action,
+      error: err.message,
+    };
+  }
+}

package/src/tools/log.ts

@@ -0,0 +1,75 @@
+import fs from "fs";
+import { BIN_EXE, CROSSPAD_PC_ROOT } from "../config.js";
+import { runBuildStream, OnLine } from "../utils/exec.js";
+
+export interface LogResult {
+  success: boolean;
+  exe_path: string;
+  stdout: string;
+  stderr: string;
+  exit_code: number | null;
+  duration_seconds: number;
+  truncated: boolean;
+}
+
+/**
+ * Launch main.exe, capture stdout/stderr for up to `timeout_seconds`,
+ * then kill the process and return the output.
+ * Streams lines in real-time via onLine callback.
+ */
+export async function crosspadLog(
+  timeoutSeconds: number = 5,
+  maxLines: number = 200,
+  onLine?: OnLine
+): Promise<LogResult> {
+  if (!fs.existsSync(BIN_EXE)) {
+    return {
+      success: false,
+      exe_path: BIN_EXE,
+      stdout: "",
+      stderr: `${BIN_EXE} not found — build first`,
+      exit_code: null,
+      duration_seconds: 0,
+      truncated: false,
+    };
+  }
+
+  onLine?.("stdout", `[crosspad] Launching ${BIN_EXE} (capturing for ${timeoutSeconds}s)...`);
+
+  const result = await runBuildStream(
+    `"${BIN_EXE}"`,
+    CROSSPAD_PC_ROOT,
+    onLine ?? (() => {}),
+    timeoutSeconds * 1000
+  );
+
+  // Truncate to maxLines
+  let stdout = result.stdout;
+  let stderr = result.stderr;
+  let truncated = false;
+
+  const stdoutLines = stdout.split("\n");
+  if (stdoutLines.length > maxLines) {
+    stdout = stdoutLines.slice(0, maxLines).join("\n");
+    truncated = true;
+  }
+
+  const stderrLines = stderr.split("\n");
+  if (stderrLines.length > maxLines) {
+    stderr = stderrLines.slice(0, maxLines).join("\n");
+    truncated = true;
+  }
+
+  // exitCode -1 = killed by timeout (expected)
+  const exitCode = result.exitCode === -1 ? null : result.exitCode;
+
+  return {
+    success: exitCode === 0 || exitCode === null,
+    exe_path: BIN_EXE,
+    stdout,
+    stderr,
+    exit_code: exitCode,
+    duration_seconds: Math.round(result.durationMs / 100) / 10,
+    truncated,
+  };
+}

package/src/tools/repos.ts

@@ -0,0 +1,75 @@
+import fs from "fs";
+import path from "path";
+import { REPOS, CROSSPAD_PC_ROOT } from "../config.js";
+import { getRepoStatus, getSubmodulePin, getHead, RepoStatus } from "../utils/git.js";
+
+export interface SubmoduleSync {
+  pinned: string | null;
+  local_head: string | null;
+  in_sync: boolean;
+}
+
+export interface ReposStatusResult {
+  repos: RepoStatus[];
+  crosspad_pc_mode: "dev-mode" | "submodule-mode" | "unknown";
+  submodule_sync: Record<string, SubmoduleSync>;
+}
+
+function detectMode(): "dev-mode" | "submodule-mode" | "unknown" {
+  const corePath = path.join(CROSSPAD_PC_ROOT, "crosspad-core");
+  try {
+    const stat = fs.lstatSync(corePath);
+    // Windows junctions report as symlinks in Node.js
+    if (stat.isSymbolicLink()) return "dev-mode";
+    // Check for .git file (submodule) or .git dir
+    const gitPath = path.join(corePath, ".git");
+    if (fs.existsSync(gitPath)) return "submodule-mode";
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+export function crosspadReposStatus(): ReposStatusResult {
+  const repos: RepoStatus[] = [];
+
+  for (const [name, repoPath] of Object.entries(REPOS)) {
+    try {
+      if (fs.existsSync(repoPath)) {
+        repos.push(getRepoStatus(name, repoPath));
+      } else {
+        repos.push({
+          name,
+          path: repoPath,
+          branch: "",
+          head: "",
+          dirtyFiles: [`(repo not found at ${repoPath})`],
+        });
+      }
+    } catch (err: any) {
+      repos.push({
+        name,
+        path: repoPath,
+        branch: "",
+        head: "",
+        dirtyFiles: [`(error: ${err.message})`],
+      });
+    }
+  }
+
+  const mode = detectMode();
+
+  // Submodule sync info
+  const submoduleSync: Record<string, SubmoduleSync> = {};
+  for (const sub of ["crosspad-core", "crosspad-gui"]) {
+    const pinned = getSubmodulePin(CROSSPAD_PC_ROOT, sub);
+    const localHead = REPOS[sub] ? getHead(REPOS[sub]) : null;
+    submoduleSync[sub] = {
+      pinned,
+      local_head: localHead,
+      in_sync: pinned !== null && localHead !== null && localHead.startsWith(pinned),
+    };
+  }
+
+  return { repos, crosspad_pc_mode: mode, submodule_sync: submoduleSync };
+}

package/src/tools/scaffold.ts

@@ -0,0 +1,229 @@
+export interface ScaffoldParams {
+  name: string; // PascalCase, e.g. "Metronome"
+  display_name?: string;
+  has_pad_logic?: boolean;
+  icon?: string;
+}
+
+export interface ScaffoldResult {
+  files: Record<string, string>;
+  cmake_patch: {
+    file: string;
+    after_pattern: string;
+    content: string;
+  };
+}
+
+export function crosspadScaffoldApp(params: ScaffoldParams): ScaffoldResult {
+  const {
+    name,
+    display_name = name,
+    has_pad_logic = false,
+    icon = "CrossPad_Logo_110w.png",
+  } = params;
+
+  const lower = name.toLowerCase();
+  const upper = name.toUpperCase();
+  const dir = `src/apps/${lower}`;
+
+  const files: Record<string, string> = {};
+
+  // --- CMakeLists.txt ---
+  const sources = [`\${CMAKE_CURRENT_SOURCE_DIR}/${name}App.cpp`];
+  if (has_pad_logic) {
+    sources.push(`\${CMAKE_CURRENT_SOURCE_DIR}/${name}PadLogic.cpp`);
+  }
+
+  files[`${dir}/CMakeLists.txt`] = `# ${display_name} app sources
+set(${upper}_APP_SOURCES
+    ${sources.join("\n    ")}
+    PARENT_SCOPE
+)
+`;
+
+  // --- App header ---
+  files[`${dir}/${name}App.hpp`] = `#pragma once
+
+#include "lvgl.h"
+
+class App;
+
+lv_obj_t* ${name}_create(lv_obj_t* parent, App* app);
+void ${name}_destroy(lv_obj_t* app_obj);
+`;
+
+  // --- App implementation ---
+  let appCpp = `/**
+ * @file ${name}App.cpp
+ * @brief ${display_name} app — LVGL GUI
+ */
+
+#include "${name}App.hpp"
+#include "pc_stubs/PcApp.hpp"
+#include "pc_stubs/pc_platform.h"
+
+#include <crosspad/app/AppRegistry.hpp>
+#include <crosspad/pad/PadManager.hpp>
+#include "crosspad-gui/components/app_lifecycle.h"
+#include "crosspad-gui/platform/IGuiPlatform.h"
+#include "crosspad_app.hpp"
+
+#include "lvgl.h"
+
+#include <cstdio>
+`;
+
+  if (has_pad_logic) {
+    appCpp += `#include "${name}PadLogic.hpp"
+#include <memory>
+
+static std::shared_ptr<${name}PadLogic> s_padLogic;
+`;
+  }
+
+  appCpp += `
+static App* s_app = nullptr;
+
+/* ── App create / destroy ────────────────────────────────────────────── */
+
+lv_obj_t* ${name}_create(lv_obj_t* parent, App* a)
+{
+    s_app = a;
+    lv_obj_t* cont = lv_obj_create(parent);
+    lv_obj_set_size(cont, lv_pct(100), lv_pct(100));
+    lv_obj_set_style_bg_color(cont, lv_color_black(), 0);
+    lv_obj_set_style_bg_opa(cont, LV_OPA_COVER, 0);
+    lv_obj_set_style_pad_all(cont, 4, 0);
+    lv_obj_set_flex_flow(cont, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_style_pad_row(cont, 2, 0);
+    lv_obj_remove_flag(cont, LV_OBJ_FLAG_SCROLLABLE);
+
+    /* ── Title bar with close button ─────────────────────────── */
+    lv_obj_t* titleBar = lv_obj_create(cont);
+    lv_obj_set_size(titleBar, lv_pct(100), 24);
+    lv_obj_set_style_bg_opa(titleBar, LV_OPA_TRANSP, 0);
+    lv_obj_set_style_border_width(titleBar, 0, 0);
+    lv_obj_set_style_pad_all(titleBar, 0, 0);
+    lv_obj_remove_flag(titleBar, LV_OBJ_FLAG_SCROLLABLE);
+
+    lv_obj_t* titleLabel = lv_label_create(titleBar);
+    lv_label_set_text(titleLabel, "${display_name}");
+    lv_obj_set_style_text_color(titleLabel, lv_color_white(), 0);
+    lv_obj_set_style_text_font(titleLabel, &lv_font_montserrat_14, 0);
+    lv_obj_align(titleLabel, LV_ALIGN_LEFT_MID, 4, 0);
+
+    lv_obj_t* closeBtn = lv_button_create(titleBar);
+    lv_obj_set_size(closeBtn, 28, 20);
+    lv_obj_align(closeBtn, LV_ALIGN_RIGHT_MID, -2, 0);
+    lv_obj_set_style_bg_color(closeBtn, lv_color_hex(0x662222), 0);
+    lv_obj_set_style_bg_color(closeBtn, lv_color_hex(0xAA3333), LV_STATE_PRESSED);
+    lv_obj_set_style_radius(closeBtn, 4, 0);
+    lv_obj_set_style_shadow_width(closeBtn, 0, 0);
+    lv_obj_t* closeLbl = lv_label_create(closeBtn);
+    lv_label_set_text(closeLbl, "X");
+    lv_obj_set_style_text_font(closeLbl, &lv_font_montserrat_12, 0);
+    lv_obj_center(closeLbl);
+    lv_obj_add_event_cb(closeBtn, [](lv_event_t*) {
+        if (s_app) crosspad_gui::app_request_close(s_app);
+    }, LV_EVENT_CLICKED, nullptr);
+`;
+
+  if (has_pad_logic) {
+    appCpp += `
+    /* ── Register pad logic ──────────────────────────────────── */
+    s_padLogic = std::make_shared<${name}PadLogic>();
+    crosspad::getPadManager().registerPadLogic("${name}", s_padLogic);
+
+    if (a) {
+        a->setOnShow([](lv_obj_t*) {
+            crosspad::getPadManager().setActivePadLogic("${name}");
+            crosspad_app_update_pad_icon();
+        });
+        a->setOnHide([](lv_obj_t*) {
+            crosspad::getPadManager().setActivePadLogic("");
+            crosspad_app_update_pad_icon();
+        });
+    }
+`;
+  }
+
+  appCpp += `
+    /* ── TODO: Add your UI here ──────────────────────────────── */
+
+    printf("[${name}] App created\\n");
+    return cont;
+}
+
+void ${name}_destroy(lv_obj_t* app_obj)
+{
+`;
+
+  if (has_pad_logic) {
+    appCpp += `    crosspad::getPadManager().setActivePadLogic("");
+    crosspad::getPadManager().unregisterPadLogic("${name}");
+    crosspad_app_update_pad_icon();
+    s_padLogic.reset();
+`;
+  }
+
+  appCpp += `    s_app = nullptr;
+    lv_obj_delete_async(app_obj);
+    printf("[${name}] App destroyed\\n");
+}
+
+/* ── App registration ────────────────────────────────────────────────── */
+
+void _register_${name}_app() {
+    static char icon_path[256];
+    snprintf(icon_path, sizeof(icon_path), "%s${icon}",
+             crosspad_gui::getGuiPlatform().assetPathPrefix());
+
+    static const crosspad::AppEntry entry = {
+        "${name}", icon_path, ${name}_create, ${name}_destroy,
+        nullptr, nullptr, nullptr, nullptr, 0
+    };
+    crosspad::AppRegistry::getInstance().registerApp(entry);
+}
+`;
+
+  files[`${dir}/${name}App.cpp`] = appCpp;
+
+  // --- Pad logic (optional) ---
+  if (has_pad_logic) {
+    files[`${dir}/${name}PadLogic.hpp`] = `#pragma once
+
+#include <crosspad/pad/IPadLogicHandler.hpp>
+
+class ${name}PadLogic : public crosspad::IPadLogicHandler {
+public:
+    void onPadPressed(uint8_t padIndex, uint8_t velocity) override;
+    void onPadReleased(uint8_t padIndex) override;
+};
+`;
+
+    files[`${dir}/${name}PadLogic.cpp`] = `#include "${name}PadLogic.hpp"
+#include <cstdio>
+
+void ${name}PadLogic::onPadPressed(uint8_t padIndex, uint8_t velocity)
+{
+    printf("[${name}PadLogic] Pad %d pressed (vel=%d)\\n", padIndex, velocity);
+    // TODO: Implement pad press logic
+}
+
+void ${name}PadLogic::onPadReleased(uint8_t padIndex)
+{
+    printf("[${name}PadLogic] Pad %d released\\n", padIndex);
+    // TODO: Implement pad release logic
+}
+`;
+  }
+
+  // --- CMake patch instructions ---
+  const cmakePatch = {
+    file: "CMakeLists.txt",
+    after_pattern: "add_subdirectory(src/apps/",
+    content: `add_subdirectory(${dir})\nlist(APPEND MAIN_SOURCES \${${upper}_APP_SOURCES})`,
+  };
+
+  return { files, cmake_patch: cmakePatch };
+}