@mmapp/react-compiler 0.1.0-alpha.12 → 0.1.0-alpha.14

package/dist/engine-binary-FKTZAR56.mjs

@@ -0,0 +1,480 @@
+import {
+  __require
+} from "./chunk-CIESM3BP.mjs";
+
+// src/cli/engine-binary.ts
+import { existsSync, mkdirSync, writeFileSync, readFileSync, chmodSync, createWriteStream, copyFileSync } from "fs";
+import { join, resolve } from "path";
+import { homedir, platform, arch } from "os";
+import { pipeline } from "stream/promises";
+import { execSync } from "child_process";
+var MMRC_BIN_DIR = join(homedir(), ".mmrc", "bin");
+var BINARY_NAME = platform() === "win32" ? "mm-api.exe" : "mm-api";
+var MANAGED_BINARY_PATH = join(MMRC_BIN_DIR, BINARY_NAME);
+var VERSION_FILE_PATH = join(MMRC_BIN_DIR, "mm-api.version");
+var METADATA_PATH = join(MMRC_BIN_DIR, "mm-api.json");
+var GITHUB_RELEASE_BASE = "https://github.com/dev-nested/mm-app/releases/download";
+var PROJECT_SEARCH_PATHS = [
+  "engine/target/release/mm-server",
+  "engine/target/debug/mm-server",
+  "mm-core/target/release/mm-server",
+  "mm-core/target/debug/mm-server",
+  "target/release/mm-server",
+  "target/debug/mm-server"
+];
+function detectPlatform() {
+  const os = platform();
+  const a = arch();
+  let triple;
+  let releasePlatform = null;
+  if (os === "linux" && a === "x64") {
+    triple = "x86_64-unknown-linux-gnu";
+    releasePlatform = "linux-x64";
+  } else if (os === "linux" && a === "arm64") {
+    triple = "aarch64-unknown-linux-gnu";
+    releasePlatform = "linux-arm64";
+  } else if (os === "darwin" && a === "x64") {
+    triple = "x86_64-apple-darwin";
+    releasePlatform = "darwin-x64";
+  } else if (os === "darwin" && a === "arm64") {
+    triple = "aarch64-apple-darwin";
+    releasePlatform = "darwin-arm64";
+  } else if (os === "win32" && a === "x64") {
+    triple = "x86_64-pc-windows-msvc";
+    releasePlatform = "windows-x64";
+  } else {
+    triple = `${a}-unknown-${os}`;
+  }
+  return { os, arch: a, triple, releasePlatform };
+}
+function getCachedVersion() {
+  try {
+    if (existsSync(VERSION_FILE_PATH)) {
+      return readFileSync(VERSION_FILE_PATH, "utf-8").trim();
+    }
+  } catch {
+  }
+  return null;
+}
+function setCachedVersion(version) {
+  mkdirSync(MMRC_BIN_DIR, { recursive: true });
+  writeFileSync(VERSION_FILE_PATH, version, "utf-8");
+}
+function readMetadata() {
+  try {
+    if (!existsSync(METADATA_PATH)) return null;
+    return JSON.parse(readFileSync(METADATA_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeMetadata(meta) {
+  mkdirSync(MMRC_BIN_DIR, { recursive: true });
+  writeFileSync(METADATA_PATH, JSON.stringify(meta, null, 2), "utf-8");
+}
+async function verifyBinary(binaryPath) {
+  if (!existsSync(binaryPath)) {
+    return { ok: false, error: `Binary not found at ${binaryPath}` };
+  }
+  try {
+    const { statSync } = __require("fs");
+    const stat = statSync(binaryPath);
+    if (stat.size < 1e6) {
+      return { ok: false, error: `Binary too small (${stat.size} bytes) \u2014 likely corrupt` };
+    }
+    if (process.platform !== "win32") {
+      const { accessSync, constants } = __require("fs");
+      try {
+        accessSync(binaryPath, constants.X_OK);
+      } catch {
+        return { ok: false, error: "Binary is not executable" };
+      }
+    }
+    return { ok: true, version: "unknown" };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+async function healthCheck(url, timeoutMs = 5e3) {
+  try {
+    const resp = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+    if (resp.ok) {
+      const data = await resp.json();
+      return { ok: true, version: data.version, db: data.database };
+    }
+    return { ok: resp.status < 500 };
+  } catch {
+    return { ok: false };
+  }
+}
+async function getEngineStatus(explicitPath) {
+  const plat = detectPlatform();
+  const resolution = findEngineBinary(explicitPath);
+  const meta = readMetadata();
+  let version = null;
+  let verified = false;
+  if (resolution.path) {
+    const verify = await verifyBinary(resolution.path);
+    if (verify.ok) {
+      version = verify.version ?? null;
+      verified = true;
+    }
+  }
+  return {
+    installed: resolution.path !== null,
+    path: resolution.path,
+    source: resolution.source,
+    version,
+    platform: plat,
+    metadata: meta,
+    verified
+  };
+}
+async function installEngine(options) {
+  const { force = false, preferBuild = false, version = "latest", cwd, prompt, fetch: fetchFn } = options ?? {};
+  const plat = detectPlatform();
+  if (!force && existsSync(MANAGED_BINARY_PATH)) {
+    const meta = readMetadata();
+    if (meta?.verified) {
+      console.error(`[mmrc] Found cached binary (${meta.version}, ${meta.platform})`);
+    }
+    const verify = await verifyBinary(MANAGED_BINARY_PATH);
+    if (verify.ok) {
+      console.error(`[mmrc] Cached binary verified: ${verify.version}`);
+      return { path: MANAGED_BINARY_PATH, source: "managed" };
+    }
+    console.error("[mmrc] Cached binary failed verification \u2014 reinstalling.");
+  }
+  if (preferBuild) {
+    return await installViaBuild(plat, version, cwd, prompt);
+  }
+  if (plat.releasePlatform) {
+    const dl = await downloadBinary({ version, platform: plat.releasePlatform, fetch: fetchFn });
+    if (dl.success) {
+      console.error("[mmrc] Verifying downloaded binary...");
+      const verify = await verifyBinary(dl.path);
+      if (verify.ok) {
+        console.error(`[mmrc] Verification passed: ${verify.version}`);
+        writeMetadata({
+          version: verify.version ?? version,
+          platform: plat.releasePlatform,
+          triple: plat.triple,
+          downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          verified: true,
+          source: "download",
+          path: dl.path
+        });
+        return { path: dl.path, source: "downloaded" };
+      }
+      console.error(`[mmrc] Binary verification FAILED: ${verify.error}`);
+      console.error("");
+      console.error(`       Platform: ${plat.releasePlatform} (${plat.triple})`);
+      console.error("       This usually means:");
+      console.error("       - Wrong architecture (e.g., ARM binary on x86)");
+      console.error("       - Missing shared libraries (try: ldd " + dl.path + ")");
+      console.error("       - Glibc version mismatch");
+      console.error("");
+      console.error("[mmrc] Falling back to build from source...\n");
+    } else {
+      console.error(`[mmrc] Download failed: ${dl.error}`);
+    }
+  } else {
+    console.error(`[mmrc] No pre-built binary for ${plat.os}/${plat.arch}.`);
+  }
+  return await installViaBuild(plat, version, cwd, prompt);
+}
+async function installViaBuild(plat, version, cwd, prompt) {
+  if (!hasCargoInstalled()) {
+    console.error("[mmrc] Rust toolchain not found (cargo not in PATH).");
+    console.error("");
+    if (platform() === "win32") {
+      console.error("  Install Rust from https://rustup.rs");
+    } else {
+      console.error("  Install Rust:");
+      console.error('    curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh');
+    }
+    console.error("");
+    console.error("  Then restart your shell and run: mmrc engine build");
+    return { path: null, source: "not-found" };
+  }
+  const built = await buildFromSource({ cwd, prompt });
+  if (!built) return { path: null, source: "not-found" };
+  console.error("[mmrc] Verifying built binary...");
+  const verify = await verifyBinary(built);
+  if (verify.ok) {
+    console.error(`[mmrc] Build verified: ${verify.version}`);
+    writeMetadata({
+      version: verify.version ?? version,
+      platform: plat.releasePlatform ?? `${plat.os}-${plat.arch}`,
+      triple: plat.triple,
+      downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: true,
+      source: "build",
+      path: built
+    });
+    return { path: built, source: "built" };
+  }
+  console.error(`[mmrc] Built binary also failed verification: ${verify.error}`);
+  return { path: null, source: "not-found" };
+}
+function buildDownloadUrl(version, releasePlatform) {
+  const tag = version.startsWith("v") ? version : `v${version}`;
+  return `${GITHUB_RELEASE_BASE}/${tag}/mm-api-${releasePlatform}`;
+}
+async function downloadBinary(options) {
+  const plat = options.platform ?? detectPlatform().releasePlatform;
+  const dest = options.dest ?? MANAGED_BINARY_PATH;
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  if (!plat) {
+    return { success: false, path: dest, error: "Unsupported platform for pre-built binaries" };
+  }
+  const url = buildDownloadUrl(options.version, plat);
+  console.error(`[mmrc] Downloading mm-api ${options.version} for ${plat}...`);
+  console.error(`[mmrc]   ${url}`);
+  try {
+    const response = await fetchFn(url, { redirect: "follow" });
+    if (!response.ok) {
+      return {
+        success: false,
+        path: dest,
+        error: `HTTP ${response.status}: ${response.statusText} (${url})`
+      };
+    }
+    mkdirSync(MMRC_BIN_DIR, { recursive: true });
+    const body = response.body;
+    if (!body) {
+      return { success: false, path: dest, error: "Empty response body" };
+    }
+    const fileStream = createWriteStream(dest);
+    await pipeline(body, fileStream);
+    chmodSync(dest, 493);
+    setCachedVersion(options.version);
+    console.error(`[mmrc] Downloaded to ${dest}`);
+    return { success: true, path: dest };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { success: false, path: dest, error: message };
+  }
+}
+function hasCargoInstalled() {
+  try {
+    execSync("cargo --version", { encoding: "utf-8", timeout: 5e3, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function askUser(question) {
+  const readline = __require("readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim().toLowerCase());
+    });
+  });
+}
+async function buildFromSource(options) {
+  const promptFn = options?.prompt ?? askUser;
+  const cwd = options?.cwd ?? process.cwd();
+  if (hasCargoInstalled()) {
+    const answer = await promptFn("[mmrc] No pre-built binary available. Build from source? (y/n) ");
+    if (answer !== "y" && answer !== "yes") return null;
+  } else {
+    const answer = await promptFn(
+      "[mmrc] No pre-built binary available and Rust is not installed.\n       Install Rust and build from source? (y/n) "
+    );
+    if (answer !== "y" && answer !== "yes") return null;
+    console.error("[mmrc] Installing Rust via rustup...");
+    try {
+      execSync('curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y', {
+        stdio: "inherit",
+        cwd,
+        timeout: 3e5
+      });
+      const cargoEnv = join(homedir(), ".cargo", "env");
+      if (existsSync(cargoEnv)) {
+        execSync(`. ${cargoEnv}`, { stdio: "pipe" });
+      }
+    } catch (err) {
+      console.error("[mmrc] Failed to install Rust:", err instanceof Error ? err.message : err);
+      return null;
+    }
+  }
+  console.error("[mmrc] Building mm-api from source (this may take several minutes)...");
+  let engineDir = null;
+  const searchPaths = [
+    join(cwd, "mm-core"),
+    join(cwd, "engine"),
+    join(cwd, "..", "mm-core"),
+    join(cwd, "..", "..", "mm-core"),
+    join(cwd, "..", "..", "mm-app", "mm-core"),
+    join(homedir(), ".mmrc", "engine-src")
+  ];
+  for (const p of searchPaths) {
+    if (existsSync(join(p, "Cargo.toml"))) {
+      engineDir = p;
+      console.error(`[mmrc] Found engine source at ${p}`);
+      break;
+    }
+  }
+  if (!engineDir) {
+    const cloneDir = join(homedir(), ".mmrc", "engine-src");
+    console.error("[mmrc] Engine source not found locally \u2014 cloning from GitHub...");
+    try {
+      if (existsSync(cloneDir)) {
+        execSync("git pull", { cwd: cloneDir, stdio: "pipe", timeout: 6e4 });
+      } else {
+        mkdirSync(join(homedir(), ".mmrc"), { recursive: true });
+        execSync(`git clone --depth 1 https://github.com/dev-nested/mm-app.git ${cloneDir}`, {
+          stdio: "inherit",
+          timeout: 12e4
+        });
+      }
+      engineDir = join(cloneDir, "mm-core");
+    } catch (err) {
+      console.error("[mmrc] Failed to clone engine source:", err instanceof Error ? err.message : err);
+      return null;
+    }
+  }
+  try {
+    execSync("cargo build --release -p mm-api", {
+      stdio: "inherit",
+      cwd: engineDir,
+      timeout: 6e5
+    });
+  } catch (err) {
+    console.error("[mmrc] Build failed:", err instanceof Error ? err.message : err);
+    return null;
+  }
+  const candidates = [
+    join(engineDir, "target", "release", "mm-server"),
+    join(engineDir, "..", "target", "release", "mm-server"),
+    join(cwd, "mm-core", "target", "release", "mm-server"),
+    join(cwd, "target", "release", "mm-server")
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) {
+      mkdirSync(MMRC_BIN_DIR, { recursive: true });
+      copyFileSync(p, MANAGED_BINARY_PATH);
+      chmodSync(MANAGED_BINARY_PATH, 493);
+      console.error(`[mmrc] Installed to ${MANAGED_BINARY_PATH}`);
+      return MANAGED_BINARY_PATH;
+    }
+  }
+  console.error("[mmrc] Build completed but binary not found in expected locations.");
+  return null;
+}
+function findEngineBinary(explicitPath, cwd) {
+  const workDir = cwd ?? process.cwd();
+  if (explicitPath) {
+    if (existsSync(explicitPath)) {
+      return { path: explicitPath, source: "explicit" };
+    }
+    return { path: null, source: "not-found" };
+  }
+  if (existsSync(MANAGED_BINARY_PATH)) {
+    return { path: MANAGED_BINARY_PATH, source: "managed" };
+  }
+  for (const rel of PROJECT_SEARCH_PATHS) {
+    const abs = resolve(workDir, rel);
+    if (existsSync(abs)) {
+      return { path: abs, source: "project" };
+    }
+  }
+  try {
+    const cmd = platform() === "win32" ? "where mm-server 2>nul || where mm-api 2>nul" : "which mm-server 2>/dev/null || which mm-api 2>/dev/null";
+    const result = execSync(cmd, { encoding: "utf-8", timeout: 5e3 }).trim();
+    if (result) {
+      return { path: result.split("\n")[0], source: "path" };
+    }
+  } catch {
+  }
+  return { path: null, source: "not-found" };
+}
+async function ensureEngineBinary(options) {
+  const found = findEngineBinary(options?.explicitPath, options?.cwd);
+  if (found.path) return found;
+  const plat = detectPlatform();
+  const version = options?.version ?? "latest";
+  if (plat.releasePlatform) {
+    const result = await downloadBinary({
+      version,
+      platform: plat.releasePlatform,
+      fetch: options?.fetch
+    });
+    if (result.success) {
+      return { path: result.path, source: "downloaded" };
+    }
+    console.error(`[mmrc] Download failed: ${result.error}`);
+  } else {
+    console.error(`[mmrc] No pre-built binary for ${plat.os}/${plat.arch}`);
+  }
+  if (!options?.nonInteractive) {
+    const built = await buildFromSource({
+      prompt: options?.prompt,
+      cwd: options?.cwd
+    });
+    if (built) {
+      return { path: built, source: "built" };
+    }
+  }
+  return { path: null, source: "not-found" };
+}
+function printInstallGuide() {
+  const plat = detectPlatform();
+  console.error("[mmrc] MindMatrix engine binary not found.\n");
+  console.error("The engine binary (mm-api) is required for local development.");
+  console.error("Choose one of the following options:\n");
+  console.error("  1. Auto-download (recommended):");
+  console.error("     mmrc dev  # auto-downloads the binary");
+  console.error("");
+  console.error("  2. Build from source (requires Rust toolchain):");
+  console.error('     curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh');
+  console.error("     cargo build --release -p mm-api");
+  console.error("");
+  console.error("  3. Download manually:");
+  if (plat.releasePlatform) {
+    console.error(`     curl -L -o ~/.mmrc/bin/mm-api \\`);
+    console.error(`       ${GITHUB_RELEASE_BASE}/v0.1.0/mm-api-${plat.releasePlatform}`);
+    console.error(`     chmod +x ~/.mmrc/bin/mm-api`);
+  } else {
+    console.error(`     # No pre-built binary for ${plat.triple} \u2014 build from source`);
+  }
+  console.error("");
+  console.error("  4. Use a remote backend instead of local:");
+  console.error("     mmrc dev --api-url https://dev.mindmatrix.club/api/v1");
+  console.error("");
+}
+function requireEngineBinary(explicitPath) {
+  const result = findEngineBinary(explicitPath);
+  if (!result.path) {
+    printInstallGuide();
+    process.exit(1);
+  }
+  return result.path;
+}
+export {
+  GITHUB_RELEASE_BASE,
+  MANAGED_BINARY_PATH,
+  METADATA_PATH,
+  VERSION_FILE_PATH,
+  askUser,
+  buildDownloadUrl,
+  buildFromSource,
+  detectPlatform,
+  downloadBinary,
+  ensureEngineBinary,
+  findEngineBinary,
+  getCachedVersion,
+  getEngineStatus,
+  hasCargoInstalled,
+  healthCheck,
+  installEngine,
+  printInstallGuide,
+  readMetadata,
+  requireEngineBinary,
+  setCachedVersion,
+  verifyBinary,
+  writeMetadata
+};

package/dist/index.js

@@ -14503,10 +14503,10 @@ async function createDevServer(options = {}) {
   }
   const {
     port = 5199,
-    src = "src/workflows",
+    src = ".",
     mode = "infer",
-    include = ["**/*.workflow.tsx"],
-    outDir = "dist/workflows",
+    include = ["models/**/*.ts", "app/**/*.tsx", "**/*.workflow.tsx"],
+    outDir = "dist",
     seed = false,
     apiUrl: rawApiUrl = "auto",
     authToken: explicitToken,

package/dist/index.mjs

@@ -21,7 +21,7 @@ import {
 } from "./chunk-XDVM4YHX.mjs";
 import {
   createDevServer
-} from "./chunk-UBDNXVL2.mjs";
+} from "./chunk-NUPJYPFU.mjs";
 import "./chunk-BZEXUPDH.mjs";
 import {
   buildEnvelope