@mmapp/react-compiler 0.1.0-alpha.18 → 0.1.0-alpha.20

package/dist/chunk-XUQ5R6F3.mjs

@@ -0,0 +1,213 @@
+// src/cli/deploy.ts
+import { glob } from "glob";
+import { readFileSync, writeFileSync } from "fs";
+import { basename } from "path";
+async function deploy(options) {
+  const dir = options.dir ?? "dist/workflows";
+  const targetLabel = options.targetName ? ` (target: ${options.targetName})` : "";
+  console.log(`[mindmatrix-react] Deploying workflows from ${dir} to ${options.apiUrl}${targetLabel}...`);
+  const files = await glob(`${dir}/**/*.workflow.json`);
+  if (files.length === 0) {
+    console.log(`[mindmatrix-react] No workflow files found in ${dir}`);
+    return { created: [], updated: [], versioned: [], skipped: [], failed: [] };
+  }
+  const result = {
+    created: [],
+    updated: [],
+    versioned: [],
+    skipped: [],
+    failed: []
+  };
+  const deployedIRs = [];
+  for (const file of files) {
+    try {
+      const ir = JSON.parse(readFileSync(file, "utf-8"));
+      const slug = ir.slug;
+      if (options.dryRun) {
+        console.log(`  [dry-run] Would deploy ${slug} (${basename(file)})`);
+        continue;
+      }
+      const existing = await fetchExistingDefinition(options.apiUrl, options.token, slug);
+      if (!existing) {
+        await createDefinition(options.apiUrl, options.token, ir);
+        console.log(`  \u2713 ${slug} (created)`);
+        result.created.push(slug);
+      } else if (existing.instanceCount === 0 || options.force) {
+        await updateDefinition(options.apiUrl, options.token, existing.id, ir);
+        console.log(`  \u2713 ${slug} (updated)`);
+        result.updated.push(slug);
+      } else {
+        const newVersion = bumpVersion(existing.version);
+        ir.version = newVersion;
+        await createDefinition(options.apiUrl, options.token, ir);
+        console.log(`  \u2713 ${slug} v${newVersion} (new version, ${existing.instanceCount} instances on v${existing.version})`);
+        result.versioned.push(slug);
+      }
+      deployedIRs.push(ir);
+    } catch (error) {
+      const slug = basename(file).replace(".workflow.json", "");
+      const msg = error.message;
+      console.error(`  \u2717 ${slug}: ${msg}`);
+      result.failed.push({ slug, error: msg });
+    }
+  }
+  if (!options.dryRun) {
+    for (const ir of deployedIRs) {
+      const serviceResult = await syncServices(options.apiUrl, options.token, ir);
+      if (serviceResult) {
+        if (!result.services) {
+          result.services = { registered: [], updated: [], failed: [] };
+        }
+        result.services.registered.push(...serviceResult.registered);
+        result.services.updated.push(...serviceResult.updated);
+        result.services.failed.push(...serviceResult.failed);
+      }
+    }
+  }
+  if (options.reportFile) {
+    writeFileSync(options.reportFile, JSON.stringify(result, null, 2), "utf-8");
+    console.log(`
+  Report written to ${options.reportFile}`);
+  }
+  const total = result.created.length + result.updated.length + result.versioned.length;
+  console.log(
+    `
+[mindmatrix-react] Deployed ${total} workflows (${result.created.length} created, ${result.updated.length} updated, ${result.versioned.length} versioned, ${result.failed.length} failed)`
+  );
+  if (result.services) {
+    const svcTotal = result.services.registered.length + result.services.updated.length;
+    if (svcTotal > 0 || result.services.failed.length > 0) {
+      console.log(
+        `[mindmatrix-react] Synced ${svcTotal} services (${result.services.registered.length} registered, ${result.services.updated.length} updated, ${result.services.failed.length} failed)`
+      );
+    }
+  }
+  return result;
+}
+async function fetchExistingDefinition(apiUrl, token, slug) {
+  try {
+    const res = await fetch(`${apiUrl}/workflow/definitions/${encodeURIComponent(slug)}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) return null;
+    const def = await res.json();
+    if (!def || !def.id) return null;
+    return {
+      id: def.id,
+      slug: def.slug,
+      version: def.version || "0.1.0",
+      instanceCount: def.instanceCount ?? def.instance_count ?? 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function createDefinition(apiUrl, token, ir) {
+  const res = await fetch(`${apiUrl}/workflow/definitions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ ...ir, visibility: "PUBLIC" })
+  });
+  if (!res.ok) {
+    const errorText = await res.text();
+    throw new Error(`Create failed: ${res.status} ${errorText}`);
+  }
+}
+async function updateDefinition(apiUrl, token, id, ir) {
+  const { slug: _slug, ...updatePayload } = ir;
+  const res = await fetch(`${apiUrl}/workflow/definitions/${id}`, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify(updatePayload)
+  });
+  if (!res.ok) {
+    const errorText = await res.text();
+    throw new Error(`Update failed: ${res.status} ${errorText}`);
+  }
+}
+function bumpVersion(version) {
+  const parts = version.split(".");
+  if (parts.length !== 3) return `${version}.1`;
+  const patch = parseInt(parts[2], 10) || 0;
+  return `${parts[0]}.${parts[1]}.${patch + 1}`;
+}
+async function syncServices(apiUrl, token, ir) {
+  const metadata = ir.metadata;
+  const orchestration = metadata?.orchestration;
+  const services = orchestration?.services;
+  if (!services || Object.keys(services).length === 0) return null;
+  const result = { registered: [], updated: [], failed: [] };
+  for (const [name, config] of Object.entries(services)) {
+    try {
+      const registration = {
+        name,
+        connection: {
+          type: config.type || "webhook",
+          url: config.url,
+          queue: config.queue
+        },
+        actions: config.actions || [],
+        labels: config.labels || {}
+      };
+      const existing = await fetchExistingService(apiUrl, token, name);
+      if (existing) {
+        await fetch(`${apiUrl}/services/${existing.id}`, {
+          method: "PATCH",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+          },
+          body: JSON.stringify(registration)
+        });
+        console.log(`  \u2713 service: ${name} (updated)`);
+        result.updated.push(name);
+      } else {
+        const res = await fetch(`${apiUrl}/services`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+          },
+          body: JSON.stringify(registration)
+        });
+        if (!res.ok) {
+          const errorText = await res.text();
+          throw new Error(`Register failed: ${res.status} ${errorText}`);
+        }
+        console.log(`  \u2713 service: ${name} (registered)`);
+        result.registered.push(name);
+      }
+    } catch (error) {
+      const msg = error.message;
+      console.error(`  \u2717 service: ${name}: ${msg}`);
+      result.failed.push(name);
+    }
+  }
+  return result;
+}
+async function fetchExistingService(apiUrl, token, name) {
+  try {
+    const res = await fetch(`${apiUrl}/services?name=${encodeURIComponent(name)}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    const servicesList = Array.isArray(data) ? data : data.services ?? data.items ?? data.data;
+    if (!servicesList || servicesList.length === 0) return null;
+    const found = servicesList.find((s) => s.name === name);
+    return found ? { id: found.id, name: found.name } : null;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  deploy,
+  syncServices
+};

package/dist/chunk-Y6FXYEAI.mjs

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/chunk-YCWC2SCO.mjs

@@ -0,0 +1,148 @@
+import {
+  mindmatrixReact
+} from "./chunk-CHLVKMQW.mjs";
+import {
+  build
+} from "./chunk-CSXYDIVC.mjs";
+
+// src/dev-server.ts
+async function createDevServer(options = {}) {
+  const {
+    port = 5199,
+    src = "src/workflows",
+    mode = "infer",
+    include = ["**/*.workflow.tsx"],
+    outDir = "dist/workflows",
+    seed = false,
+    apiUrl = "http://localhost:4200/api/v1",
+    authToken = process.env.MINDMATRIX_TOKEN,
+    ws: enableWs = true,
+    open = false
+  } = options;
+  const clients = /* @__PURE__ */ new Set();
+  const pluginOptions = {
+    mode,
+    include,
+    outDir,
+    seedOnCompile: seed,
+    apiUrl,
+    authToken
+  };
+  const notifyPlugin = {
+    name: "mindmatrix-dev-notify",
+    enforce: "post",
+    handleHotUpdate(ctx) {
+      const isWorkflow = include.some((pattern) => {
+        const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<GLOBSTAR>>").replace(/\*/g, "[^/]*").replace(/<<GLOBSTAR>>/g, ".*").replace(/\?/g, ".");
+        return new RegExp(regex).test(ctx.file);
+      });
+      if (!isWorkflow) return;
+      const message = JSON.stringify({
+        type: "workflow:compiled",
+        file: ctx.file,
+        timestamp: ctx.timestamp
+      });
+      for (const client of clients) {
+        try {
+          if (client.readyState === 1) {
+            client.send(message);
+          }
+        } catch {
+          clients.delete(client);
+        }
+      }
+      console.log(`[mm-dev] Compiled ${ctx.file.split("/").pop()} \u2014 notified ${clients.size} client(s)`);
+    }
+  };
+  const viteConfig = {
+    root: process.cwd(),
+    server: {
+      port,
+      open,
+      host: true
+    },
+    plugins: [
+      mindmatrixReact(pluginOptions),
+      notifyPlugin
+    ],
+    logLevel: "info"
+  };
+  const { createServer } = await import("vite");
+  const vite = await createServer(viteConfig);
+  await vite.listen();
+  const resolvedPort = vite.config.server.port ?? port;
+  if (enableWs && vite.httpServer) {
+    try {
+      const wsModule = await Function('return import("ws")')();
+      const WebSocketServer = wsModule.WebSocketServer ?? wsModule.default?.WebSocketServer;
+      if (WebSocketServer) {
+        const wss = new WebSocketServer({
+          server: vite.httpServer,
+          path: "/__mm_dev"
+        });
+        wss.on("connection", (socket) => {
+          clients.add(socket);
+          console.log(`[mm-dev] Editor connected (${clients.size} total)`);
+          socket.on("close", () => {
+            clients.delete(socket);
+            console.log(`[mm-dev] Editor disconnected (${clients.size} total)`);
+          });
+          socket.send(JSON.stringify({
+            type: "mm:connected",
+            version: "0.1.0",
+            capabilities: ["compile", "seed", "notify"]
+          }));
+        });
+      }
+    } catch {
+      console.warn("[mm-dev] ws package not available \u2014 WebSocket notifications disabled");
+    }
+  }
+  console.log(`
+[mm-dev] MindMatrix Dev Server running`);
+  console.log(`  Local:     http://localhost:${resolvedPort}`);
+  console.log(`  WebSocket: ws://localhost:${resolvedPort}/__mm_dev`);
+  console.log(`  Watching:  ${src} (${include.join(", ")})`);
+  if (seed) {
+    console.log(`  Seeding:   ${apiUrl}`);
+  }
+  console.log();
+  return {
+    vite,
+    port: resolvedPort,
+    clients,
+    async rebuild() {
+      console.log("[mm-dev] Full rebuild triggered...");
+      const result = await build({ src, outDir, mode });
+      const message = JSON.stringify({
+        type: "workflow:rebuild",
+        compiled: result.compiled,
+        errors: result.errors,
+        timestamp: Date.now()
+      });
+      for (const client of clients) {
+        try {
+          if (client.readyState === 1) client.send(message);
+        } catch {
+          clients.delete(client);
+        }
+      }
+      return result;
+    },
+    async close() {
+      for (const client of clients) {
+        try {
+          client.close();
+        } catch {
+        }
+      }
+      clients.clear();
+      await vite.close();
+      console.log("[mm-dev] Server stopped");
+    }
+  };
+}
+
+export {
+  createDevServer
+};