@mmapp/react-compiler 0.1.0-alpha.11 → 0.1.0-alpha.13

package/dist/cli/index.mjs

@@ -10,10 +10,12 @@ import {
 } from "../chunk-ABYPKRSB.mjs";
 import {
   build
-} from "../chunk-VLTKQDJ3.mjs";
+} from "../chunk-DNWDIPH2.mjs";
 import "../chunk-5M7DKKBC.mjs";
 import "../chunk-7T6Q5KAA.mjs";
-import "../chunk-CIESM3BP.mjs";
+import {
+  __require
+} from "../chunk-CIESM3BP.mjs";
 
 // src/cli/test.ts
 import { glob } from "glob";
@@ -339,9 +341,89 @@ async function main() {
     const src = getFlag("--src") ?? devCfg.src;
     const mode = getFlag("--mode") ?? devCfg.mode;
     const seed = hasFlag("--seed") || devCfg.seed === true;
-    const apiUrl = hasFlag("--local") ? "local" : getFlag("--api-url") ?? devCfg.apiUrl;
+    const explicitApiUrl = getFlag("--api-url") ?? devCfg.apiUrl;
+    const isLocal = hasFlag("--local") || !explicitApiUrl || explicitApiUrl === "local";
     const authToken = getFlag("--token") ?? devCfg.token;
     const open = hasFlag("--open") || devCfg.open === true;
+    const apiPort = getFlag("--api-port") ? parseInt(getFlag("--api-port"), 10) : 4200;
+    let engineProcess = null;
+    if (isLocal) {
+      const { findEngineBinary, installEngine, verifyBinary } = await import("../engine-binary-QQUDACBJ.mjs");
+      let resolution = findEngineBinary(getFlag("--binary"));
+      if (resolution.path) {
+        const verify = await verifyBinary(resolution.path);
+        if (!verify.ok) {
+          console.error(`[mmrc] Binary at ${resolution.path} failed verification: ${verify.error}`);
+          console.error("[mmrc] Attempting reinstall...\n");
+          resolution = { path: null, source: "not-found" };
+        }
+      }
+      if (!resolution.path) {
+        const installed = await installEngine({
+          force: true,
+          version: getFlag("--engine-version") ?? "latest"
+        });
+        if (installed.path) {
+          resolution = installed;
+        }
+      }
+      if (!resolution.path) {
+        console.log("[mmrc] No local engine binary available.");
+        console.log("[mmrc] Dev server will connect to a remote API or start in-memory mode.");
+        console.log("[mmrc] (For full local mode: `mmrc engine install` or `mmrc engine build`)\n");
+      } else {
+        console.log(`[mmrc] Starting local engine: ${resolution.path} (${resolution.source})`);
+        const { spawn: spawnProcess } = __require("child_process");
+        engineProcess = spawnProcess(resolution.path, [], {
+          stdio: ["ignore", "pipe", "pipe"],
+          env: {
+            ...process.env,
+            DATABASE_URL: `sqlite://${process.cwd()}/dev.db`,
+            JWT_SECRET: "dev-secret-mmrc-local",
+            PORT: String(apiPort),
+            RUST_LOG: "mm_api=info,mm_storage=info"
+          }
+        });
+        if (engineProcess.stdout) {
+          engineProcess.stdout.on("data", (data) => {
+            for (const line of data.toString().split("\n").filter(Boolean)) {
+              console.log(`  [engine] ${line}`);
+            }
+          });
+        }
+        if (engineProcess.stderr) {
+          engineProcess.stderr.on("data", (data) => {
+            for (const line of data.toString().split("\n").filter(Boolean)) {
+              console.error(`  [engine] ${line}`);
+            }
+          });
+        }
+        engineProcess.on("error", (err) => {
+          console.error(`[mmrc] Engine failed to start: ${err.message}`);
+          process.exit(1);
+        });
+        const healthUrl = `http://localhost:${apiPort}/health`;
+        let healthy = false;
+        for (let i = 0; i < 30; i++) {
+          try {
+            const res = await fetch(healthUrl, { signal: AbortSignal.timeout(500) });
+            if (res.ok) {
+              healthy = true;
+              break;
+            }
+          } catch {
+          }
+          await new Promise((r) => setTimeout(r, 500));
+        }
+        if (!healthy) {
+          console.error("[mmrc] Engine failed to become healthy within 15s.");
+          engineProcess.kill();
+          process.exit(1);
+        }
+        console.log(`[mmrc] Engine healthy at http://localhost:${apiPort}`);
+      }
+    }
+    const apiUrl = engineProcess ? `http://localhost:${apiPort}/api/v1` : explicitApiUrl || "auto";
     const { createDevServer } = await import("../dev-server.mjs");
     const server = await createDevServer({
       port,
@@ -353,6 +435,10 @@ async function main() {
       open
     });
     const shutdown = async () => {
+      if (engineProcess) {
+        console.log("[mmrc] Stopping engine...");
+        engineProcess.kill("SIGTERM");
+      }
       await server.close();
       process.exit(0);
     };
@@ -373,7 +459,7 @@ async function main() {
     const result = await test({ src });
     if (!result.success) process.exit(1);
   } else if (command === "deploy") {
-    const { loadMmrcConfig, resolveTarget } = await import("../config-PL24KEWL.mjs");
+    const { loadMmrcConfig, resolveTarget } = await import("../config-RVLNOB24.mjs");
     const mmrcConfig = loadMmrcConfig();
     const targetFlag = getFlag("--target");
     const explicitApiUrl = getFlag("--api-url");
@@ -478,7 +564,7 @@ async function main() {
       console.error('[mmrc] Error: name is required\n  Usage: mmrc init <name> [--description "..."] [--icon "..."] [--author "..."]');
       process.exit(1);
     }
-    const { init } = await import("../init-7FJENUDK.mjs");
+    const { init } = await import("../init-DY6SJDRX.mjs");
     await init({
       name,
       description: getFlag("--description"),
@@ -538,7 +624,7 @@ async function main() {
     }
   } else if (command === "config") {
     const subcommand = args[1];
-    const { getConfig, getConfigValue, setConfigValue, flattenConfig, findConfigPath, writeConfigFile } = await import("../config-PL24KEWL.mjs");
+    const { getConfig, getConfigValue, setConfigValue, flattenConfig, findConfigPath, writeConfigFile } = await import("../config-RVLNOB24.mjs");
     if (subcommand === "get") {
       const key = args[2];
       if (!key) {
@@ -607,6 +693,121 @@ async function main() {
       console.error("  Usage: mmrc server [start|migrate|init|status|config]");
       process.exit(1);
     }
+  } else if (command === "engine") {
+    const subcommand = args[1];
+    const {
+      detectPlatform,
+      findEngineBinary,
+      getEngineStatus,
+      installEngine,
+      buildFromSource: _buildFromSource,
+      verifyBinary,
+      healthCheck,
+      readMetadata,
+      MANAGED_BINARY_PATH: _MANAGED_BINARY_PATH
+    } = await import("../engine-binary-QQUDACBJ.mjs");
+    if (subcommand === "status") {
+      const status = await getEngineStatus(getFlag("--binary"));
+      const plat = detectPlatform();
+      console.log("\n  MindMatrix Engine Status");
+      console.log("  " + "-".repeat(48));
+      console.log(`  Platform:   ${plat.releasePlatform ?? `${plat.os}-${plat.arch}`} (${plat.triple})`);
+      console.log(`  Installed:  ${status.installed ? "yes" : "no"}`);
+      if (status.path) {
+        console.log(`  Path:       ${status.path}`);
+        console.log(`  Source:     ${status.source}`);
+      }
+      console.log(`  Verified:   ${status.verified ? "yes" : "no"}`);
+      if (status.version) {
+        console.log(`  Version:    ${status.version}`);
+      }
+      const meta = readMetadata();
+      if (meta) {
+        console.log(`  Downloaded: ${meta.downloadedAt}`);
+        console.log(`  Built via:  ${meta.source}`);
+      }
+      console.log("");
+    } else if (subcommand === "install") {
+      const force = hasFlag("--force");
+      const version = getFlag("--version") ?? "latest";
+      const result = await installEngine({ force, version });
+      if (!result.path) {
+        console.error("[mmrc] Engine installation failed.");
+        process.exit(1);
+      }
+      console.log(`
+[mmrc] Engine installed: ${result.path} (${result.source})`);
+    } else if (subcommand === "build") {
+      const result = await installEngine({ preferBuild: true, force: true });
+      if (!result.path) {
+        console.error("[mmrc] Engine build failed.");
+        process.exit(1);
+      }
+      console.log(`
+[mmrc] Engine built and cached: ${result.path}`);
+    } else if (subcommand === "update") {
+      const version = getFlag("--version") ?? "latest";
+      console.log("[mmrc] Checking for engine updates...");
+      const result = await installEngine({ force: true, version });
+      if (!result.path) {
+        console.error("[mmrc] Engine update failed.");
+        process.exit(1);
+      }
+      console.log(`
+[mmrc] Engine updated: ${result.path} (${result.source})`);
+    } else if (subcommand === "verify") {
+      const resolution = findEngineBinary(getFlag("--binary"));
+      if (!resolution.path) {
+        console.error("[mmrc] No engine binary found. Run `mmrc engine install` first.");
+        process.exit(1);
+      }
+      console.log(`[mmrc] Verifying binary: ${resolution.path}`);
+      const verify = await verifyBinary(resolution.path);
+      if (!verify.ok) {
+        console.error(`[mmrc] --version check FAILED: ${verify.error}`);
+        process.exit(1);
+      }
+      console.log(`[mmrc] --version check passed: ${verify.version}`);
+      const apiPort = getFlag("--port") ? parseInt(getFlag("--port"), 10) : 14200;
+      console.log(`[mmrc] Starting engine on port ${apiPort} for health check...`);
+      const { spawn } = await import("child_process");
+      const proc = spawn(resolution.path, [], {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: {
+          ...process.env,
+          DATABASE_URL: "sqlite://:memory:",
+          JWT_SECRET: "verify-test",
+          PORT: String(apiPort),
+          RUST_LOG: "error"
+        }
+      });
+      let healthy = false;
+      for (let i = 0; i < 20; i++) {
+        const h = await healthCheck(`http://localhost:${apiPort}/health`, 1e3);
+        if (h.ok) {
+          healthy = true;
+          console.log(`[mmrc] /health check passed${h.version ? ` (v${h.version})` : ""}${h.db ? ` [${h.db}]` : ""}`);
+          break;
+        }
+        await new Promise((r) => setTimeout(r, 500));
+      }
+      proc.kill("SIGTERM");
+      if (!healthy) {
+        console.error("[mmrc] /health check FAILED: engine did not become healthy within 10s.");
+        process.exit(1);
+      }
+      console.log("\n[mmrc] All verification checks passed.");
+    } else {
+      console.error(`[mmrc] Unknown engine subcommand: ${subcommand ?? "(none)"}`);
+      console.error("  Usage: mmrc engine [status|install|build|update|verify]");
+      console.error("");
+      console.error("  status   Show installed binary path, version, platform");
+      console.error("  install  Download or build mm-api binary");
+      console.error("  build    Explicitly build from source (cargo build --release -p mm-api)");
+      console.error("  update   Check for newer version and download/build");
+      console.error("  verify   Run --version and /health check against the binary");
+      process.exit(1);
+    }
   } else if (command === "version" || command === "-v" || command === "--version" || hasFlag("--version") || hasFlag("-v")) {
     const { readFileSync: readFileSync2 } = await import("fs");
     const { resolve: resolve2, dirname } = await import("path");
@@ -648,6 +849,7 @@ Commands:
   verify  Compile + run verification layers (structural, reachability, safety, liveness, etc.)
   deploy  Compile + upload workflows to backend DB
   pull    Fetch a definition from DB and scaffold local project
+  engine  Manage the mm-api engine binary (install, build, verify, update)
 
 Usage:
   mmrc init <name> [options]
@@ -710,6 +912,17 @@ Usage:
     --token     Auth token (or use mmrc login / MMRC_TOKEN env var)
     --out       Output directory (default: <slug>/)
 
+  mmrc engine <subcommand> [options]
+    status      Show installed binary path, version, platform
+    install     Download or build mm-api binary (--force to reinstall, --version VER)
+    build       Explicitly build from source (cargo build --release -p mm-api)
+    update      Check for newer version and download/build (--version VER)
+    verify      Run --version and /health check (--binary PATH, --port PORT)
+
+  Platforms: darwin-arm64, darwin-x64, linux-x64, linux-arm64, windows-x64
+  Binary location: ~/.mmrc/bin/mm-api
+  Metadata: ~/.mmrc/bin/mm-api.json
+
 Token resolution (for deploy/pull):
   1. --token flag (highest priority)
   2. MMRC_TOKEN environment variable
@@ -733,6 +946,10 @@ Examples:
   mmrc build --src src/workflows
   mmrc deploy --build --src . --api-url http://localhost:4200/api/v1
   mmrc pull my-blueprint --out ./my-project
+  mmrc engine status
+  mmrc engine install
+  mmrc engine build
+  mmrc engine verify
     `);
   }
 }

package/dist/config-RVLNOB24.mjs

@@ -0,0 +1,219 @@
+import "./chunk-CIESM3BP.mjs";
+
+// src/cli/config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve, join } from "path";
+var DEFAULT_CONFIG = {
+  dev: {
+    port: 5199,
+    apiPort: 4200,
+    db: "sqlite://mm-dev.db",
+    redis: "",
+    api: "local",
+    seed: false,
+    open: false
+  },
+  build: {
+    mode: "infer",
+    outDir: "dist/workflows",
+    skipTypeCheck: false
+  },
+  test: {
+    minCoverage: 80,
+    minMutationScore: 60,
+    integration: false
+  },
+  environments: {
+    local: { apiUrl: "http://localhost:4200/api/v1" },
+    dev: { apiUrl: "https://dev.mindmatrix.club/api/v1" }
+  },
+  defaultTarget: "local"
+};
+function isPlainObject(val) {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const srcVal = source[key];
+    const tgtVal = target[key];
+    if (isPlainObject(srcVal) && isPlainObject(tgtVal)) {
+      result[key] = deepMerge(tgtVal, srcVal);
+    } else if (srcVal !== void 0) {
+      result[key] = srcVal;
+    }
+  }
+  return result;
+}
+function findConfigPath(startDir) {
+  let dir = startDir ?? process.cwd();
+  const root = resolve("/");
+  while (true) {
+    for (const name of ["mmrc.config.ts", "mmrc.config.json"]) {
+      const candidate = join(dir, name);
+      if (existsSync(candidate)) return candidate;
+    }
+    const parent = resolve(dir, "..");
+    if (parent === dir || parent === root) break;
+    dir = parent;
+  }
+  return null;
+}
+function loadConfigFromFile(configPath) {
+  const content = readFileSync(configPath, "utf-8");
+  if (configPath.endsWith(".json")) {
+    try {
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+  let js = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(?<![:'"])\/\/.*$/gm, "").replace(/^import\s+.*$/gm, "").replace(/^export\s+default\s+/m, "module.exports = ").replace(/^export\s+/gm, "").replace(/:\s*MmrcConfig/g, "").replace(/as\s+const/g, "").replace(/satisfies\s+\w+/g, "");
+  js = `function defineMmrc(c) { return c; }
+${js}`;
+  try {
+    const m = {};
+    const fn = new Function("module", "exports", "require", js);
+    fn(m, m, () => ({}));
+    const exported = m.exports ?? m;
+    return isPlainObject(exported) ? exported : {};
+  } catch {
+    return {};
+  }
+}
+function getConfig(startDir) {
+  const configPath = findConfigPath(startDir);
+  if (!configPath) return { ...DEFAULT_CONFIG };
+  const userConfig = loadConfigFromFile(configPath);
+  return deepMerge(DEFAULT_CONFIG, userConfig);
+}
+function getConfigValue(config, key) {
+  const parts = key.split(".");
+  let current = config;
+  for (const part of parts) {
+    if (!isPlainObject(current)) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function setConfigValue(config, key, value) {
+  const parts = key.split(".");
+  let current = config;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!isPlainObject(current[part])) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  const last = parts[parts.length - 1];
+  if (value === "true") current[last] = true;
+  else if (value === "false") current[last] = false;
+  else if (/^\d+$/.test(value)) current[last] = parseInt(value, 10);
+  else current[last] = value;
+}
+function flattenConfig(obj, prefix = "") {
+  const entries = [];
+  if (!isPlainObject(obj)) {
+    entries.push([prefix, String(obj)]);
+    return entries;
+  }
+  for (const [key, val] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (isPlainObject(val)) {
+      entries.push(...flattenConfig(val, fullKey));
+    } else {
+      entries.push([fullKey, String(val)]);
+    }
+  }
+  return entries;
+}
+function writeConfigFile(configPath, config) {
+  const json = JSON.stringify(config, null, 2);
+  const content = `/**
+ * mmrc.config.ts \u2014 MindMatrix React Compiler configuration.
+ *
+ * Configures the mmrc CLI for local dev, builds, tests, and deploy targets.
+ * Edit directly or run \`mmrc config set <key> <value>\`.
+ */
+
+const config = ${json};
+
+export default config;
+`;
+  writeFileSync(configPath, content, "utf-8");
+}
+function resolveTarget(targetName, config, fallbackApiUrl) {
+  if (!config || !config.environments) {
+    return { name: targetName ?? "default", apiUrl: fallbackApiUrl, token: null };
+  }
+  const name = targetName ?? config.defaultTarget ?? "local";
+  const env = config.environments[name];
+  if (!env) {
+    const available = Object.keys(config.environments).join(", ");
+    throw new Error(`Unknown target "${name}". Available environments: ${available}`);
+  }
+  return { name, apiUrl: env.apiUrl, token: env.token ?? null };
+}
+function generateMmrcConfig() {
+  return `/**
+ * mmrc.config.ts \u2014 MindMatrix React Compiler configuration.
+ *
+ * Configures the mmrc CLI for local dev, builds, tests, and deploy targets.
+ * Edit directly or run \`mmrc config set <key> <value>\`.
+ */
+
+const config = {
+  dev: {
+    port: 5199,
+    apiPort: 4200,
+    db: 'sqlite://mm-dev.db',
+    redis: '',
+    api: 'https://dev.mindmatrix.club/api/v1',
+    seed: false,
+    open: false,
+  },
+
+  build: {
+    mode: 'infer',
+    outDir: 'dist/workflows',
+    skipTypeCheck: false,
+  },
+
+  test: {
+    minCoverage: 80,
+    minMutationScore: 60,
+    integration: false,
+  },
+
+  environments: {
+    local: { apiUrl: 'http://localhost:4200/api/v1' },
+    dev: { apiUrl: 'https://dev.mindmatrix.club/api/v1' },
+  },
+
+  defaultTarget: 'local',
+};
+
+export default config;
+`;
+}
+function loadMmrcConfig(dir) {
+  const path = findConfigPath(dir);
+  if (!path) return null;
+  const partial = loadConfigFromFile(path);
+  return deepMerge(DEFAULT_CONFIG, partial);
+}
+export {
+  DEFAULT_CONFIG,
+  deepMerge,
+  findConfigPath,
+  flattenConfig,
+  generateMmrcConfig,
+  getConfig,
+  getConfigValue,
+  loadConfigFromFile,
+  loadMmrcConfig,
+  resolveTarget,
+  setConfigValue,
+  writeConfigFile
+};

package/dist/dev-server.js

@@ -11522,6 +11522,10 @@ async function build(options = {}) {
             definitions: [],
             errorDetails: typeErrors
           };
+        } else if (output.includes("not the tsc command") || output.includes("Cannot find module") || output.includes("ERR_MODULE_NOT_FOUND") || output.includes("command not found")) {
+          console.warn(`[mindmatrix-react] TypeScript not installed \u2014 skipping type check.`);
+          console.warn(`  Run \`npm install\` to enable type checking, or use --skip-type-check.
+`);
         } else {
           console.error(`
 [mindmatrix-react] Type check failed:
@@ -12256,6 +12260,33 @@ function broadcast(clients, data) {
   }
 }
 async function createDevServer(options = {}) {
+  const { existsSync: existsSync3 } = await import("fs");
+  const { resolve: resolve2 } = await import("path");
+  const nodeModulesPath = resolve2(process.cwd(), "node_modules");
+  if (!existsSync3(nodeModulesPath)) {
+    console.error(`
+[mmrc] Error: Dependencies not installed.
+`);
+    console.error(`  Run one of these in your project directory first:
+`);
+    console.error(`    npm install`);
+    console.error(`    pnpm install`);
+    console.error(`    yarn install
+`);
+    process.exit(1);
+  }
+  try {
+    await import("vite");
+  } catch {
+    console.error(`
+[mmrc] Error: 'vite' is not installed.
+`);
+    console.error(`  Install it:
+`);
+    console.error(`    npm install -D vite
+`);
+    process.exit(1);
+  }
   const {
     port = 5199,
     src = "src/workflows",
@@ -12317,6 +12348,45 @@ async function createDevServer(options = {}) {
   }
   const pluginOpts = { mode, include, outDir, seedOnCompile: seed, apiUrl, authToken: token };
   const proxyTarget = apiUrl.replace(/\/api\/v1\/?$/, "") || apiUrl;
+  const devPlayerPlugin = {
+    name: "mindmatrix-dev-player",
+    resolveId(id) {
+      if (id === "virtual:mm-dev-player") return "\0virtual:mm-dev-player";
+      return null;
+    },
+    load(id) {
+      if (id !== "\0virtual:mm-dev-player") return null;
+      return `
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { DevPlayer } from '@mmapp/react/player';
+
+const tree = window.__MM_DEV_TREE__ || { type: 'Text', props: { children: 'No tree loaded. Compile a workflow to see the preview.' } };
+const scopes = window.__MM_DEV_SCOPES__ || {};
+
+function App() {
+  const [currentTree, setTree] = React.useState(tree);
+  const [currentScopes, setScopes] = React.useState(scopes);
+
+  React.useEffect(() => {
+    const ws = new WebSocket('ws://' + location.host + '/__mm_dev');
+    ws.onmessage = (ev) => {
+      try {
+        const msg = JSON.parse(ev.data);
+        if (msg.type === 'workflow:compiled' && msg.tree) setTree(msg.tree);
+        if (msg.type === 'workflow:compiled' && msg.scopes) setScopes(msg.scopes);
+      } catch {}
+    };
+    return () => ws.close();
+  }, []);
+
+  return React.createElement(DevPlayer, { tree: currentTree, scopes: currentScopes, title: document.title || 'MindMatrix Dev' });
+}
+
+createRoot(document.getElementById('root')).render(React.createElement(App));
+`;
+    }
+  };
   let deployInFlight = false;
   const compileDeployPlugin = {
     name: "mindmatrix-dev-compile-deploy",
@@ -12361,6 +12431,7 @@ async function createDevServer(options = {}) {
     plugins: [
       mindmatrixReact(pluginOpts),
       compileDeployPlugin,
+      devPlayerPlugin,
       { name: "mindmatrix-error-overlay", configureServer(server) {
         server.middlewares.use(errorOverlayMiddleware());
       } }

package/dist/dev-server.mjs

@@ -1,8 +1,8 @@
 import {
   createDevServer
-} from "./chunk-UDDTWG5J.mjs";
+} from "./chunk-UBDNXVL2.mjs";
 import "./chunk-BZEXUPDH.mjs";
-import "./chunk-VLTKQDJ3.mjs";
+import "./chunk-DNWDIPH2.mjs";
 import "./chunk-5M7DKKBC.mjs";
 import "./chunk-7T6Q5KAA.mjs";
 import "./chunk-CIESM3BP.mjs";