crosspad-mcp-server 4.0.0

package/src/utils/exec.ts

@@ -0,0 +1,376 @@
+import { execSync, spawn, ChildProcess, SpawnOptions } from "child_process";
+import { VCVARSALL, IS_WINDOWS, IDF_PATH } from "../config.js";
+
+/** Callback invoked for each line of stdout/stderr during streaming exec. */
+export type OnLine = (stream: "stdout" | "stderr", line: string) => void;
+
+let cachedMsvcEnv: Record<string, string> | null = null;
+
+/**
+ * Capture MSVC environment by running vcvarsall.bat and parsing `set` output.
+ * Cached for the lifetime of the server process. Windows-only.
+ */
+export function getMsvcEnv(): Record<string, string> {
+  if (!IS_WINDOWS) {
+    return { ...process.env } as Record<string, string>;
+  }
+  if (cachedMsvcEnv) return cachedMsvcEnv;
+
+  const cmd = `"${VCVARSALL}" x64 >nul 2>&1 && set`;
+  const output = execSync(cmd, {
+    shell: "cmd.exe",
+    encoding: "utf-8",
+    timeout: 30_000,
+  });
+
+  const env: Record<string, string> = {};
+  for (const line of output.split("\n")) {
+    const eq = line.indexOf("=");
+    if (eq > 0) {
+      env[line.slice(0, eq)] = line.slice(eq + 1).trimEnd();
+    }
+  }
+
+  cachedMsvcEnv = env;
+  return env;
+}
+
+export interface ExecResult {
+  success: boolean;
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  durationMs: number;
+}
+
+/**
+ * Run a command with the MSVC environment, capturing output.
+ */
+export function runWithMsvc(
+  cmd: string,
+  cwd: string,
+  timeoutMs = 300_000
+): ExecResult {
+  const env = getMsvcEnv();
+  const start = Date.now();
+
+  try {
+    const stdout = execSync(cmd, {
+      cwd,
+      env,
+      shell: "cmd.exe",
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return {
+      success: true,
+      stdout: normalizeLineEndings(stdout),
+      stderr: "",
+      exitCode: 0,
+      durationMs: Date.now() - start,
+    };
+  } catch (err: any) {
+    return {
+      success: false,
+      stdout: normalizeLineEndings(err.stdout?.toString() ?? ""),
+      stderr: normalizeLineEndings(err.stderr?.toString() ?? ""),
+      exitCode: err.status ?? 1,
+      durationMs: Date.now() - start,
+    };
+  }
+}
+
+/**
+ * Run a command in the default shell, capturing output.
+ */
+export function runCommand(
+  cmd: string,
+  cwd: string,
+  timeoutMs = 60_000
+): ExecResult {
+  const start = Date.now();
+  try {
+    const stdout = execSync(cmd, {
+      cwd,
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return {
+      success: true,
+      stdout: normalizeLineEndings(stdout),
+      stderr: "",
+      exitCode: 0,
+      durationMs: Date.now() - start,
+    };
+  } catch (err: any) {
+    return {
+      success: false,
+      stdout: normalizeLineEndings(err.stdout?.toString() ?? ""),
+      stderr: normalizeLineEndings(err.stderr?.toString() ?? ""),
+      exitCode: err.status ?? 1,
+      durationMs: Date.now() - start,
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// STREAMING VARIANTS (spawn-based, line-by-line callbacks)
+// ═══════════════════════════════════════════════════════════════════════
+
+/**
+ * Helper: spawn a process and stream stdout/stderr line-by-line via onLine.
+ * Returns the same ExecResult as the sync variants.
+ */
+function spawnStreaming(
+  cmd: string,
+  cwd: string,
+  env: Record<string, string> | undefined,
+  shell: string | boolean,
+  onLine: OnLine,
+  timeoutMs: number
+): Promise<ExecResult> {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const child = spawn(cmd, [], {
+      cwd,
+      env,
+      shell,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let stdoutBuf = "";
+    let stderrBuf = "";
+    let killed = false;
+
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill("SIGTERM");
+    }, timeoutMs);
+
+    function flushLines(buf: string, stream: "stdout" | "stderr"): string {
+      const parts = buf.split("\n");
+      // Last part is incomplete — keep it in buffer
+      for (let i = 0; i < parts.length - 1; i++) {
+        const line = parts[i].replace(/\r$/, "");
+        onLine(stream, line);
+      }
+      return parts[parts.length - 1];
+    }
+
+    child.stdout?.on("data", (chunk: Buffer) => {
+      const text = chunk.toString();
+      stdout += text;
+      stdoutBuf += text;
+      stdoutBuf = flushLines(stdoutBuf, "stdout");
+    });
+
+    child.stderr?.on("data", (chunk: Buffer) => {
+      const text = chunk.toString();
+      stderr += text;
+      stderrBuf += text;
+      stderrBuf = flushLines(stderrBuf, "stderr");
+    });
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      // Flush remaining partial lines
+      if (stdoutBuf.length > 0) onLine("stdout", stdoutBuf.replace(/\r$/, ""));
+      if (stderrBuf.length > 0) onLine("stderr", stderrBuf.replace(/\r$/, ""));
+
+      resolve({
+        success: killed ? false : code === 0,
+        stdout: normalizeLineEndings(stdout),
+        stderr: normalizeLineEndings(stderr),
+        exitCode: killed ? -1 : (code ?? 1),
+        durationMs: Date.now() - start,
+      });
+    });
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({
+        success: false,
+        stdout: normalizeLineEndings(stdout),
+        stderr: normalizeLineEndings(stderr + "\n" + err.message),
+        exitCode: 1,
+        durationMs: Date.now() - start,
+      });
+    });
+  });
+}
+
+/**
+ * Run a command with the MSVC environment, streaming output line-by-line.
+ */
+export function runWithMsvcStream(
+  cmd: string,
+  cwd: string,
+  onLine: OnLine,
+  timeoutMs = 300_000
+): Promise<ExecResult> {
+  const env = getMsvcEnv();
+  return spawnStreaming(cmd, cwd, env, "cmd.exe", onLine, timeoutMs);
+}
+
+/**
+ * Run a command in the default shell, streaming output line-by-line.
+ */
+export function runCommandStream(
+  cmd: string,
+  cwd: string,
+  onLine: OnLine,
+  timeoutMs = 60_000
+): Promise<ExecResult> {
+  return spawnStreaming(cmd, cwd, undefined, true, onLine, timeoutMs);
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// ESP-IDF ENVIRONMENT
+// ═══════════════════════════════════════════════════════════════════════
+
+let cachedIdfEnv: Record<string, string> | null = null;
+
+/**
+ * Capture ESP-IDF environment by running export.bat and parsing `set` output.
+ * Must unset MSYSTEM to prevent ESP-IDF from rejecting MSYS shells.
+ * Cached for the lifetime of the server process. Windows-only.
+ */
+export function getIdfEnv(): Record<string, string> {
+  if (!IS_WINDOWS) {
+    return { ...process.env } as Record<string, string>;
+  }
+  if (cachedIdfEnv) return cachedIdfEnv;
+
+  const exportBat = `${IDF_PATH}\\export.bat`;
+  const cmd = `set MSYSTEM=&& set PYTHONIOENCODING=utf-8&& call ${exportBat} >nul 2>&1 && set`;
+  const output = execSync(cmd, {
+    shell: "cmd.exe",
+    encoding: "utf-8",
+    timeout: 60_000,
+  });
+
+  const env: Record<string, string> = {};
+  for (const line of output.split("\n")) {
+    const eq = line.indexOf("=");
+    if (eq > 0) {
+      env[line.slice(0, eq)] = line.slice(eq + 1).trimEnd();
+    }
+  }
+
+  cachedIdfEnv = env;
+  return env;
+}
+
+/**
+ * Run a command with the ESP-IDF environment, capturing output.
+ */
+export function runWithIdf(
+  cmd: string,
+  cwd: string,
+  timeoutMs = 600_000
+): ExecResult {
+  const env = getIdfEnv();
+  const start = Date.now();
+
+  try {
+    const stdout = execSync(cmd, {
+      cwd,
+      env,
+      shell: "cmd.exe",
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return {
+      success: true,
+      stdout: normalizeLineEndings(stdout),
+      stderr: "",
+      exitCode: 0,
+      durationMs: Date.now() - start,
+    };
+  } catch (err: any) {
+    return {
+      success: false,
+      stdout: normalizeLineEndings(err.stdout?.toString() ?? ""),
+      stderr: normalizeLineEndings(err.stderr?.toString() ?? ""),
+      exitCode: err.status ?? 1,
+      durationMs: Date.now() - start,
+    };
+  }
+}
+
+/**
+ * Run a command with the ESP-IDF environment, streaming output line-by-line.
+ */
+export function runWithIdfStream(
+  cmd: string,
+  cwd: string,
+  onLine: OnLine,
+  timeoutMs = 600_000
+): Promise<ExecResult> {
+  const env = getIdfEnv();
+  return spawnStreaming(cmd, cwd, env, "cmd.exe", onLine, timeoutMs);
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// PLATFORM-AGNOSTIC BUILD WRAPPERS
+// ═══════════════════════════════════════════════════════════════════════
+
+/**
+ * Run a build command with the appropriate environment for the current platform.
+ * Windows: MSVC env + cmd.exe shell. Unix: default shell.
+ */
+export function runBuild(
+  cmd: string,
+  cwd: string,
+  timeoutMs = 300_000
+): ExecResult {
+  if (IS_WINDOWS) {
+    return runWithMsvc(cmd, cwd, timeoutMs);
+  }
+  return runCommand(cmd, cwd, timeoutMs);
+}
+
+/**
+ * Run a build command with streaming output, platform-aware.
+ * Windows: MSVC env + cmd.exe shell. Unix: default shell.
+ */
+export function runBuildStream(
+  cmd: string,
+  cwd: string,
+  onLine: OnLine,
+  timeoutMs = 300_000
+): Promise<ExecResult> {
+  if (IS_WINDOWS) {
+    return runWithMsvcStream(cmd, cwd, onLine, timeoutMs);
+  }
+  return runCommandStream(cmd, cwd, onLine, timeoutMs);
+}
+
+/** Strip \r from Windows line endings */
+function normalizeLineEndings(s: string): string {
+  return s.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+/**
+ * Spawn a detached process (for crosspad_run).
+ */
+export function spawnDetached(
+  exe: string,
+  args: string[],
+  cwd: string
+): number | null {
+  const opts: SpawnOptions = {
+    cwd,
+    detached: true,
+    stdio: "ignore",
+  };
+  const child = spawn(exe, args, opts);
+  child.unref();
+  return child.pid ?? null;
+}

package/src/utils/git.ts

@@ -0,0 +1,45 @@
+import { runCommand } from "./exec.js";
+
+export interface RepoStatus {
+  name: string;
+  path: string;
+  branch: string;
+  head: string;
+  dirtyFiles: string[];
+}
+
+export function getRepoStatus(name: string, repoPath: string): RepoStatus {
+  const branch = runCommand("git branch --show-current", repoPath);
+  const log = runCommand("git log --oneline -1", repoPath);
+  const status = runCommand("git status --porcelain", repoPath);
+
+  return {
+    name,
+    path: repoPath,
+    branch: branch.stdout.trim(),
+    head: log.stdout.trim(),
+    dirtyFiles: status.stdout
+      .trim()
+      .split("\n")
+      .filter((l) => l.length > 0),
+  };
+}
+
+export function getSubmodulePin(
+  repoPath: string,
+  submodule: string
+): string | null {
+  const result = runCommand(
+    `git submodule status ${submodule}`,
+    repoPath
+  );
+  if (!result.success) return null;
+  // Output format: " abc1234 submodule-name (desc)" or "+abc1234 ..."
+  const match = result.stdout.match(/[+ -]?([0-9a-f]+)/);
+  return match ? match[1] : null;
+}
+
+export function getHead(repoPath: string): string | null {
+  const result = runCommand("git rev-parse HEAD", repoPath);
+  return result.success ? result.stdout.trim() : null;
+}

package/src/utils/remote-client.ts

@@ -0,0 +1,107 @@
+/**
+ * TCP client for communicating with the CrossPad simulator's remote control server.
+ * Protocol: newline-delimited JSON over TCP on localhost:19840.
+ */
+
+import { Socket } from "net";
+
+const REMOTE_PORT = 19840;
+const REMOTE_HOST = "127.0.0.1";
+const CONNECT_TIMEOUT = 3000;
+const RESPONSE_TIMEOUT = 15000;
+
+export interface RemoteResponse {
+  ok: boolean;
+  [key: string]: unknown;
+}
+
+/**
+ * Send a JSON command to the running simulator and return the response.
+ * Opens a fresh TCP connection per call (simple, stateless).
+ */
+export function sendRemoteCommand(command: Record<string, unknown>): Promise<RemoteResponse> {
+  return new Promise((resolve, reject) => {
+    const socket = new Socket();
+    let buffer = "";
+    let resolved = false;
+
+    const cleanup = () => {
+      if (!resolved) {
+        resolved = true;
+        socket.destroy();
+      }
+    };
+
+    // Connect timeout
+    socket.setTimeout(CONNECT_TIMEOUT);
+
+    socket.on("connect", () => {
+      // Extend timeout for response
+      socket.setTimeout(RESPONSE_TIMEOUT);
+
+      // Send command as newline-delimited JSON
+      const msg = JSON.stringify(command) + "\n";
+      socket.write(msg);
+    });
+
+    socket.on("data", (data) => {
+      buffer += data.toString();
+
+      // Look for newline-delimited response
+      const nlIdx = buffer.indexOf("\n");
+      if (nlIdx >= 0) {
+        const line = buffer.slice(0, nlIdx);
+        resolved = true;
+        socket.destroy();
+        try {
+          resolve(JSON.parse(line) as RemoteResponse);
+        } catch {
+          resolve({ ok: false, error: "invalid JSON response", raw: line });
+        }
+      }
+    });
+
+    socket.on("timeout", () => {
+      cleanup();
+      reject(new Error("Connection/response timeout — is the simulator running?"));
+    });
+
+    socket.on("error", (err: NodeJS.ErrnoException) => {
+      cleanup();
+      if (err.code === "ECONNREFUSED") {
+        reject(new Error("Connection refused — simulator is not running or remote control is disabled. Start with crosspad_run first."));
+      } else {
+        reject(new Error(`TCP error: ${err.message}`));
+      }
+    });
+
+    socket.on("close", () => {
+      if (!resolved) {
+        resolved = true;
+        if (buffer.length > 0) {
+          try {
+            resolve(JSON.parse(buffer) as RemoteResponse);
+          } catch {
+            resolve({ ok: false, error: "incomplete response", raw: buffer });
+          }
+        } else {
+          reject(new Error("Connection closed without response"));
+        }
+      }
+    });
+
+    socket.connect(REMOTE_PORT, REMOTE_HOST);
+  });
+}
+
+/**
+ * Check if the simulator's remote control server is reachable.
+ */
+export async function isSimulatorRunning(): Promise<boolean> {
+  try {
+    const resp = await sendRemoteCommand({ cmd: "ping" });
+    return resp.ok === true;
+  } catch {
+    return false;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"]
+}