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

package/dist/cli/index.js

@@ -14454,36 +14454,24 @@ async function verifyBinary(binaryPath) {
   if (!(0, import_fs6.existsSync)(binaryPath)) {
     return { ok: false, error: `Binary not found at ${binaryPath}` };
   }
-  return new Promise((resolve7) => {
-    try {
-      const proc = (0, import_child_process2.spawn)(binaryPath, ["--version"], {
-        stdio: ["ignore", "pipe", "pipe"],
-        timeout: 1e4
-      });
-      let stdout = "";
-      let stderr = "";
-      proc.stdout?.on("data", (d) => {
-        stdout += d.toString();
-      });
-      proc.stderr?.on("data", (d) => {
-        stderr += d.toString();
-      });
-      proc.on("error", (err) => {
-        resolve7({ ok: false, error: `Failed to execute: ${err.message}` });
-      });
-      proc.on("close", (code) => {
-        if (code === 0) {
-          const output = stdout.trim() || stderr.trim();
-          const version = output.replace(/^mm[-_](?:server|api)\s*/i, "").trim() || "unknown";
-          resolve7({ ok: true, version });
-        } else {
-          resolve7({ ok: false, error: `Exited with code ${code}. ${stderr.trim()}` });
-        }
-      });
-    } catch (e) {
-      resolve7({ ok: false, error: `Spawn failed: ${e instanceof Error ? e.message : String(e)}` });
+  try {
+    const { statSync: statSync3 } = require("fs");
+    const stat = statSync3(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 {
@@ -14691,11 +14679,46 @@ async function buildFromSource(options) {
       return null;
     }
   }
-  console.error("[mmrc] Building mm-api from source (this may take a few minutes)...");
+  console.error("[mmrc] Building mm-api from source (this may take several minutes)...");
+  let engineDir = null;
+  const searchPaths = [
+    (0, import_path5.join)(cwd, "mm-core"),
+    (0, import_path5.join)(cwd, "engine"),
+    (0, import_path5.join)(cwd, "..", "mm-core"),
+    (0, import_path5.join)(cwd, "..", "..", "mm-core"),
+    (0, import_path5.join)(cwd, "..", "..", "mm-app", "mm-core"),
+    (0, import_path5.join)((0, import_os2.homedir)(), ".mmrc", "engine-src")
+  ];
+  for (const p of searchPaths) {
+    if ((0, import_fs6.existsSync)((0, import_path5.join)(p, "Cargo.toml"))) {
+      engineDir = p;
+      console.error(`[mmrc] Found engine source at ${p}`);
+      break;
+    }
+  }
+  if (!engineDir) {
+    const cloneDir = (0, import_path5.join)((0, import_os2.homedir)(), ".mmrc", "engine-src");
+    console.error("[mmrc] Engine source not found locally \u2014 cloning from GitHub...");
+    try {
+      if ((0, import_fs6.existsSync)(cloneDir)) {
+        (0, import_child_process2.execSync)("git pull", { cwd: cloneDir, stdio: "pipe", timeout: 6e4 });
+      } else {
+        (0, import_fs6.mkdirSync)((0, import_path5.join)((0, import_os2.homedir)(), ".mmrc"), { recursive: true });
+        (0, import_child_process2.execSync)(`git clone --depth 1 https://github.com/dev-nested/mm-app.git ${cloneDir}`, {
+          stdio: "inherit",
+          timeout: 12e4
+        });
+      }
+      engineDir = (0, import_path5.join)(cloneDir, "mm-core");
+    } catch (err) {
+      console.error("[mmrc] Failed to clone engine source:", err instanceof Error ? err.message : err);
+      return null;
+    }
+  }
   try {
     (0, import_child_process2.execSync)("cargo build --release -p mm-api", {
       stdio: "inherit",
-      cwd,
+      cwd: engineDir,
       timeout: 6e5
     });
   } catch (err) {
@@ -14703,6 +14726,8 @@ async function buildFromSource(options) {
     return null;
   }
   const candidates = [
+    (0, import_path5.join)(engineDir, "target", "release", "mm-server"),
+    (0, import_path5.join)(engineDir, "..", "target", "release", "mm-server"),
     (0, import_path5.join)(cwd, "mm-core", "target", "release", "mm-server"),
     (0, import_path5.join)(cwd, "target", "release", "mm-server")
   ];
@@ -15761,10 +15786,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,
@@ -16576,6 +16601,20 @@ async function init(options) {
     console.error(`[mmrc] Error: Directory already exists: ${blueprintDir}`);
     process.exit(1);
   }
+  try {
+    const pkgPath = require.resolve("@mmapp/react-compiler/package.json");
+    const { version } = require(pkgPath);
+    console.log(`[mmrc] v${version}`);
+  } catch {
+    try {
+      const { readFileSync: readFileSync11 } = require("fs");
+      const { resolve: resolve7, dirname: dirname4 } = require("path");
+      const pkg = JSON.parse(readFileSync11(resolve7(__dirname, "../../package.json"), "utf-8"));
+      console.log(`[mmrc] v${pkg.version}`);
+    } catch {
+      console.log(`[mmrc]`);
+    }
+  }
   console.log(`[mmrc] Creating blueprint: ${name}
 `);
   (0, import_fs10.mkdirSync)((0, import_path8.join)(blueprintDir, "models"), { recursive: true });
@@ -19270,63 +19309,67 @@ async function main() {
           force: true,
           version: getFlag("--engine-version") ?? "latest"
         });
-        if (!installed.path) {
-          console.error("[mmrc] Could not obtain a working engine binary.");
-          process.exit(1);
+        if (installed.path) {
+          resolution = installed;
         }
-        resolution = installed;
       }
-      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 (!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.stderr) {
-        engineProcess.stderr.on("data", (data) => {
-          for (const line of data.toString().split("\n").filter(Boolean)) {
-            console.error(`  [engine] ${line}`);
-          }
+        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);
         });
-      }
-      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;
+        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 {
           }
-        } catch {
+          await new Promise((r) => setTimeout(r, 500));
         }
-        await new Promise((r) => setTimeout(r, 500));
-      }
-      if (!healthy) {
-        console.error("[mmrc] Engine failed to become healthy within 15s.");
-        engineProcess.kill();
-        process.exit(1);
+        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}`);
       }
-      console.log(`[mmrc] Engine healthy at http://localhost:${apiPort}`);
     }
-    const apiUrl = isLocal ? `http://localhost:${apiPort}/api/v1` : explicitApiUrl;
+    const apiUrl = engineProcess ? `http://localhost:${apiPort}/api/v1` : explicitApiUrl || "auto";
     const { createDevServer: createDevServer2 } = await Promise.resolve().then(() => (init_dev_server(), dev_server_exports));
     const server = await createDevServer2({
       port,

package/dist/cli/index.mjs

@@ -348,7 +348,7 @@ async function main() {
     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");
+      const { findEngineBinary, installEngine, verifyBinary } = await import("../engine-binary-FKTZAR56.mjs");
       let resolution = findEngineBinary(getFlag("--binary"));
       if (resolution.path) {
         const verify = await verifyBinary(resolution.path);
@@ -363,63 +363,67 @@ async function main() {
           force: true,
           version: getFlag("--engine-version") ?? "latest"
         });
-        if (!installed.path) {
-          console.error("[mmrc] Could not obtain a working engine binary.");
-          process.exit(1);
+        if (installed.path) {
+          resolution = installed;
         }
-        resolution = installed;
       }
-      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 (!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.stderr) {
-        engineProcess.stderr.on("data", (data) => {
-          for (const line of data.toString().split("\n").filter(Boolean)) {
-            console.error(`  [engine] ${line}`);
-          }
+        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);
         });
-      }
-      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;
+        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 {
           }
-        } catch {
+          await new Promise((r) => setTimeout(r, 500));
         }
-        await new Promise((r) => setTimeout(r, 500));
-      }
-      if (!healthy) {
-        console.error("[mmrc] Engine failed to become healthy within 15s.");
-        engineProcess.kill();
-        process.exit(1);
+        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}`);
       }
-      console.log(`[mmrc] Engine healthy at http://localhost:${apiPort}`);
     }
-    const apiUrl = isLocal ? `http://localhost:${apiPort}/api/v1` : explicitApiUrl;
+    const apiUrl = engineProcess ? `http://localhost:${apiPort}/api/v1` : explicitApiUrl || "auto";
     const { createDevServer } = await import("../dev-server.mjs");
     const server = await createDevServer({
       port,
@@ -560,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-2CRSUGV5.mjs");
+    const { init } = await import("../init-DY6SJDRX.mjs");
     await init({
       name,
       description: getFlag("--description"),
@@ -701,7 +705,7 @@ async function main() {
       healthCheck,
       readMetadata,
       MANAGED_BINARY_PATH: _MANAGED_BINARY_PATH
-    } = await import("../engine-binary-QQUDACBJ.mjs");
+    } = await import("../engine-binary-FKTZAR56.mjs");
     if (subcommand === "status") {
       const status = await getEngineStatus(getFlag("--binary"));
       const plat = detectPlatform();

package/dist/dev-server.js

@@ -12289,10 +12289,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/dev-server.mjs

@@ -1,6 +1,6 @@
 import {
   createDevServer
-} from "./chunk-UBDNXVL2.mjs";
+} from "./chunk-NUPJYPFU.mjs";
 import "./chunk-BZEXUPDH.mjs";
 import "./chunk-DNWDIPH2.mjs";
 import "./chunk-5M7DKKBC.mjs";