m8flow 1.1.0 → 1.1.1

package/bundled/backend/services/llm_service.py

@@ -74,35 +74,52 @@ def _mark_rate_limited(model: str) -> None:
 
 # ── Catalogue helpers ──────────────────────────────────────────────────────────
 
+_CATALOGUE_CACHE: str | None = None   # built-in templates, parsed once
+
 def _template_catalogue(custom_components: list[dict] | None = None) -> str:
-    """Detailed catalogue: id, category, inputs, outputs."""
-    from core.parser import parse_node_code
-    lines: list[str] = []
-    for t in TEMPLATES:
-        schema = parse_node_code(t["code"])
-        data_ins  = [i.name for i in schema.inputs  if i.kind == "data"]
-        field_ins = [f"{i.name}:{i.kind}={i.default}" for i in schema.inputs  if i.kind != "data"]
-        outs      = [o.name for o in schema.outputs]
-        lines.append(
-            f"{t['id']} [{t['category']}]\n"
-            f"  inputs : {data_ins or '(none)'}  fields: {field_ins or '(none)'}\n"
-            f"  outputs: {outs or '(none)'}"
-        )
-        
-    if custom_components:
-        lines.append("\n=== USER CUSTOM COMPONENTS (Preferred if applicable) ===")
-        for c in custom_components:
-            schema = c.get("schema", {})
-            data_ins  = [i["name"] for i in schema.get("inputs", []) if i.get("kind") == "data"]
-            field_ins = [f"{i['name']}:{i.get('kind')}={i.get('default')}" for i in schema.get("inputs", []) if i.get("kind") != "data"]
-            outs      = [o["name"] for o in schema.get("outputs", [])]
+    """Detailed catalogue: id, category, inputs, outputs.
+
+    Built-in templates are parsed ONCE and cached — they never change at runtime.
+    Custom components are appended fresh each call because they can vary per session.
+    """
+    global _CATALOGUE_CACHE
+
+    # ── Built-ins: parse once, then serve from cache ──────────────────────────
+    if _CATALOGUE_CACHE is None:
+        from core.parser import parse_node_code
+        lines: list[str] = []
+        for t in TEMPLATES:
+            try:
+                schema    = parse_node_code(t["code"])
+                data_ins  = [i.name for i in schema.inputs  if i.kind == "data"]
+                field_ins = [f"{i.name}:{i.kind}={i.default}" for i in schema.inputs  if i.kind != "data"]
+                outs      = [o.name for o in schema.outputs]
+            except Exception:
+                data_ins, field_ins, outs = [], [], []
             lines.append(
-                f"{c.get('id')} [Custom] \"{c.get('label')}\"\n"
+                f"{t['id']} [{t['category']}]\n"
                 f"  inputs : {data_ins or '(none)'}  fields: {field_ins or '(none)'}\n"
                 f"  outputs: {outs or '(none)'}"
             )
-            
-    return "\n".join(lines)
+        _CATALOGUE_CACHE = "\n".join(lines)
+        logger.debug("Template catalogue cached (%d templates)", len(TEMPLATES))
+
+    if not custom_components:
+        return _CATALOGUE_CACHE
+
+    # ── Custom nodes: always fresh ────────────────────────────────────────────
+    custom_lines = ["\n=== USER CUSTOM COMPONENTS (Preferred if applicable) ==="]
+    for c in custom_components:
+        schema    = c.get("schema", {})
+        data_ins  = [i["name"] for i in schema.get("inputs", [])  if i.get("kind") == "data"]
+        field_ins = [f"{i['name']}:{i.get('kind')}={i.get('default')}" for i in schema.get("inputs", []) if i.get("kind") != "data"]
+        outs      = [o["name"] for o in schema.get("outputs", [])]
+        custom_lines.append(
+            f"{c.get('id')} [Custom] \"{c.get('label')}\"\n"
+            f"  inputs : {data_ins or '(none)'}  fields: {field_ins or '(none)'}\n"
+            f"  outputs: {outs or '(none)'}"
+        )
+    return _CATALOGUE_CACHE + "\n".join(custom_lines)
 
 
 def _allowed_type_ids() -> set[str]:

package/lib/backend.js

@@ -8,6 +8,7 @@
  */
 import { execa }   from 'execa';
 import path        from 'path';
+import fs          from 'fs';
 import { log }     from './logger.js';
 import { fileURLToPath } from 'url';
 
@@ -18,13 +19,39 @@ const SUPPRESS_VENV  = /^\s*(INFO|DEBUG):\s*(Started|Waiting|Application startup
 
 // ── Docker helpers ────────────────────────────────────────────────────────────
 
-async function isDockerAvailable() {
+let _dockerAvailableCache = null;   // null = not checked yet
+
+async function isDockerAvailable(m8flowHome) {
+  // Cache in memory for the process lifetime — `docker info` takes 1-2 s
+  if (_dockerAvailableCache !== null) return _dockerAvailableCache;
+
+  // Also cache to disk so repeated CLI invocations skip the check for 24 h
+  if (m8flowHome) {
+    const flagFile = path.join(m8flowHome, '.docker_available');
+    try {
+      const stat = fs.statSync(flagFile);
+      const ageMs = Date.now() - stat.mtimeMs;
+      if (ageMs < 86_400_000) {               // 24-hour TTL
+        _dockerAvailableCache = fs.readFileSync(flagFile, 'utf8').trim() === '1';
+        return _dockerAvailableCache;
+      }
+    } catch {}
+  }
+
   try {
-    const { exitCode } = await execa('docker', ['info'], { reject: false, timeout: 5_000 });
-    return exitCode === 0;
+    const { exitCode } = await execa('docker', ['info'], { reject: false, timeout: 4_000 });
+    _dockerAvailableCache = exitCode === 0;
   } catch {
-    return false;
+    _dockerAvailableCache = false;
   }
+
+  if (m8flowHome) {
+    try {
+      fs.writeFileSync(path.join(m8flowHome, '.docker_available'), _dockerAvailableCache ? '1' : '0');
+    } catch {}
+  }
+
+  return _dockerAvailableCache;
 }
 
 async function isImageBuilt() {
@@ -123,6 +150,8 @@ function spawnVenvBackend(venvPython, backendDir, port, m8flowHome, verbose) {
   const env = {
     ...process.env,
     PYTHONUNBUFFERED:    '1',
+    // Use the pre-compiled .pyc cache built by warmup.py — cuts import time by ~70%
+    PYTHONPYCACHEPREFIX: path.join(m8flowHome, 'pycache'),
     M8FLOW_UPLOAD_DIR:   path.join(m8flowHome, 'uploads'),
     M8FLOW_MODELS_DIR:   path.join(m8flowHome, 'models'),
     M8FLOW_PIPELINE_DIR: path.join(m8flowHome, 'pipelines'),
@@ -171,7 +200,7 @@ function spawnVenvBackend(venvPython, backendDir, port, m8flowHome, verbose) {
  */
 export async function spawnBackend(venvPython, backendDir, port, m8flowHome, verbose) {
   // ── Try Docker first ──────────────────────────────────────────────────────
-  const dockerAvailable = await isDockerAvailable();
+  const dockerAvailable = await isDockerAvailable(m8flowHome);
 
   if (dockerAvailable) {
     // Stop any leftover container from a previous run

package/lib/ports.js

@@ -3,6 +3,48 @@
  */
 import detectPort from 'detect-port';
 import net        from 'net';
+import { execa }  from 'execa';
+
+/**
+ * Kill whatever process is listening on `port`.
+ * Used to clean up stale m8flow backends from previous sessions that
+ * didn't get properly terminated (common on Windows after a forced close).
+ *
+ * Cross-platform:
+ *   Windows → netstat -ano + taskkill /F /T
+ *   Mac/Linux → lsof + kill -9
+ */
+export async function killProcessOnPort(port) {
+  try {
+    if (process.platform === 'win32') {
+      // netstat output:  TCP    127.0.0.1:8000    0.0.0.0:0    LISTENING    12345
+      const { stdout = '' } = await execa('netstat', ['-ano'], {
+        reject: false, timeout: 4_000,
+      });
+      for (const line of stdout.split('\n')) {
+        // Match lines with our port in LISTENING state
+        if (!line.includes(`:${port}`) || !line.toUpperCase().includes('LISTEN')) continue;
+        const parts = line.trim().split(/\s+/);
+        const pid   = parts[parts.length - 1];
+        if (!pid || pid === '0' || !/^\d+$/.test(pid)) continue;
+        // /T = kill entire process tree, /F = force
+        await execa('taskkill', ['/PID', pid, '/F', '/T'], { reject: false });
+        await sleep(600);   // let the OS release the port
+        return;
+      }
+    } else {
+      // lsof -ti:<port> lists PIDs listening on that port
+      await execa('sh', ['-c', `lsof -ti:${port} | xargs kill -9 2>/dev/null; true`], {
+        reject: false, timeout: 4_000,
+      });
+      await sleep(400);
+    }
+  } catch {
+    // Non-fatal — if we can't kill it, detect-port will find a different port
+  }
+}
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
 
 /**
  * Returns a free port starting from `preferred`.

package/lib/run.js

@@ -13,16 +13,17 @@
  *   9. Open browser
  *  10. Keep alive until Ctrl+C
  */
-import path     from 'path';
-import os       from 'os';
-import fs       from 'fs';
+import path           from 'path';
+import os             from 'os';
+import fs             from 'fs';
+import { execSync }   from 'child_process';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
 
 import { checkPython, ensureVenv, installDeps } from './setup.js';
 import { spawnBackend }                          from './backend.js';
 import { serveStatic }                           from './server.js';
-import { resolvePort, waitForPort }              from './ports.js';
+import { resolvePort, waitForPort, killProcessOnPort } from './ports.js';
 import { banner, log, spin, readyBox }           from './logger.js';
 
 const require   = createRequire(import.meta.url);
@@ -67,13 +68,19 @@ export async function run({
   // ── 4. pip install ────────────────────────────────────────────────────────
   await installDeps(venvPython, BACKEND_DIR, M8FLOW_HOME);
 
-  // ── 5. Ports ──────────────────────────────────────────────────────────────
+  // ── 5. Ports — kill stale backends first ────────────────────────────────────
   log.section('Network');
+
+  // Kill any leftover process from a previous session BEFORE checking port availability.
+  // On Windows, Ctrl+C sometimes leaves the Python/uvicorn process running.
+  await killProcessOnPort(backendPort);
+  await killProcessOnPort(frontendPort);
+
   const fe = await resolvePort(frontendPort, 'frontend');
   const be = await resolvePort(backendPort,  'backend');
 
-  if (fe.changed) log.warn(`Port ${fe.from} busy → using ${fe.port} for the frontend`);
-  if (be.changed) log.warn(`Port ${be.from} busy → using ${be.port} for the backend`);
+  if (fe.changed) log.warn(`Port ${fe.from} still busy after cleanup → using ${fe.port}`);
+  if (be.changed) log.warn(`Port ${be.from} still busy after cleanup → using ${be.port}`);
 
   log.ok(`Frontend  → http://localhost:${fe.port}`);
   log.ok(`Backend   → http://localhost:${be.port}`);
@@ -127,7 +134,16 @@ export async function run({
   const shutdown = (signal) => {
     log.blank();
     log.info(`Received ${signal} — shutting down…`);
-    try { backendProc.kill(); } catch {}
+
+    // On Windows, .kill() only kills the execa wrapper — the Python subprocess
+    // often survives, leaving the port busy on the next run.
+    // Use taskkill /T to kill the entire process tree.
+    if (process.platform === 'win32' && backendProc.pid) {
+      try { execSync(`taskkill /PID ${backendProc.pid} /F /T`, { stdio: 'ignore' }); } catch {}
+    } else {
+      try { backendProc.kill('SIGTERM'); } catch {}
+    }
+
     try { httpServer.close(); } catch {}
     log.ok('Goodbye!\n');
     process.exit(0);

package/lib/setup.js

@@ -209,6 +209,30 @@ export async function installDeps(venvPython, backendDir, m8flowHome) {
 
   fs.writeFileSync(hashFile, hash);
   console.log(`  ${chalk.green('✔')}  ${chalk.bold('ML engine ready')} — all ${total} packages installed`);
+
+  // ── Pre-compile bytecode so first server startup is instant ───────────────
+  // warmup.py imports every heavy library once; Python writes .pyc to
+  // ~/.m8flow/pycache/ (via PYTHONPYCACHEPREFIX). Subsequent uvicorn starts
+  // read compiled bytecode instead of parsing source — cuts cold start by 70%.
+  const warmupScript = path.join(backendDir, 'warmup.py');
+  if (fs.existsSync(warmupScript)) {
+    process.stdout.write(`  ⏳  Pre-compiling ML bytecode (one-time)… `);
+    try {
+      await execa(venvPython, [warmupScript], {
+        cwd: backendDir,
+        env: {
+          ...process.env,
+          PYTHONPYCACHEPREFIX: path.join(m8flowHome, 'pycache'),
+          PYTHONDONTWRITEBYTECODE: '0',
+        },
+        timeout: 120_000,
+        reject:  false,
+      });
+      process.stdout.write(chalk.green('done\n'));
+    } catch {
+      process.stdout.write(chalk.dim('skipped\n'));  // non-fatal
+    }
+  }
   console.log();
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "m8flow",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Visual ML Pipeline Builder — run locally with one command",
   "keywords": [
     "machine-learning",
@@ -33,9 +33,9 @@
     "ora": "^8.1.1"
   },
   "scripts": {
-    "build":          "node scripts/build.js",
-    "dev":            "node scripts/build.js && npm install -g . --force",
+    "build": "node scripts/build.js",
+    "dev": "node scripts/build.js && npm install -g . --force",
     "prepublishOnly": "node scripts/build.js",
-    "postinstall":    "node scripts/check-docker.js"
+    "postinstall": "node scripts/check-docker.js"
   }
 }