@melaya/runner 1.0.55 → 1.0.56

package/dist/connection.js

@@ -472,6 +472,266 @@ export async function connect(opts) {
             socket.emit("runner:runComplete", { runId: payload.runId, status: "failed" });
         }
     });
+    // ── Trading Crew strategy spawn ──────────────────────────────────────
+    // Mirrors the runner:run pipeline path but for `strategy_type='agent_crew'`
+    // rows whose runtime_mode='local_runner'. The server's
+    // StrategyCrewRuntime branches on runtimeMode='local_runner' (decision
+    // tree in Obsidian/07 Trading/Trading Strategies/Trading Agents Crew/
+    // Local vs Cloud.md), emits `runner:start_crew_strategy` to the user's
+    // socket, and this handler boots the same crew worker as the cloud
+    // pool would — except spawned as a plain Python subprocess on the
+    // user's hardware so lmstudio/ollama personas reach localhost:1234 /
+    // localhost:11434 directly. There's no code signature here because the
+    // cfg.generated_code originates from the Melaya server (cloud-trusted),
+    // not from operator input. Agent message events flow back via the
+    // existing runner:event → runnerNamespace.pushEvent path so the FE
+    // Studio's RenderRunningCrew bubbles populate in real time.
+    socket.on("runner:start_crew_strategy", async (payload) => {
+        const runId = payload.run_id;
+        const sid = payload.strategy_id;
+        const cfg = payload.cfg ?? {};
+        console.log(chalk.hex("#10b981")(`\n  ▶ Trading crew: ${sid.slice(0, 16)}… (run ${runId.slice(0, 10)}…)`));
+        try {
+            const mainPyContent = String(cfg.generated_code ?? "").trim();
+            if (!mainPyContent) {
+                // Server-side fallback should always populate generated_code now
+                // (runnerNamespace.startCrewStrategyOnRunner backfills via
+                // renderCrewFallbackMainPy). If we still arrive here, the server
+                // is older than this runner — surface a clear message instead of
+                // a silent no-op.
+                console.log(chalk.red("  ✗ Crew cfg missing generated_code — server-side fallback unavailable"));
+                socket.emit("runner:event", {
+                    run_id: runId,
+                    event_type: "agent_message",
+                    replyId: `crew-init-${runId}`,
+                    replyName: "Runner",
+                    replyRole: "system",
+                    msg: {
+                        id: `crew-init-${runId}`,
+                        name: "Runner",
+                        role: "system",
+                        content: [{ type: "text", text: "Crew cfg missing generated_code. Re-save the crew in the Studio." }],
+                        metadata: {},
+                        timestamp: new Date().toISOString(),
+                    },
+                });
+                socket.emit("runner:runComplete", { runId, status: "failed" });
+                return;
+            }
+            // Ensure shared modules cached. The crew worker imports from
+            // `shared.runtime.trading_crew_personas` (per the codegen
+            // template's import_path) which lives in the same shared/ tree
+            // the pipeline runner uses.
+            await ensureSharedModules(opts.serverUrl, "latest");
+            // Dedicated venv with agentscope + anthropic + openai installed.
+            const { ensurePythonEnv } = await import("./pythonEnv.js");
+            const envResult = await ensurePythonEnv(opts.pythonPath, "latest", (msg) => {
+                console.log(chalk.gray(`  [venv] ${msg}`));
+                socket.emit("runner:event", {
+                    run_id: runId,
+                    event_type: "pipeline_phase",
+                    project: `crew-${sid.slice(-12)}`,
+                    step: 1,
+                    total: 5,
+                    label: `venv: ${msg}`,
+                    status: "started",
+                });
+            });
+            if (!envResult.ok) {
+                console.log(chalk.red(`  ✗ python venv bootstrap failed: ${envResult.reason}`));
+                socket.emit("runner:event", {
+                    run_id: runId,
+                    event_type: "agent_message",
+                    project: `crew-${sid.slice(-12)}`,
+                    replyId: `venv-${runId}`,
+                    replyName: "Runner",
+                    replyRole: "system",
+                    msg: {
+                        id: `venv-${runId}`,
+                        name: "Runner",
+                        role: "system",
+                        content: [{ type: "text", text: `Python env bootstrap failed: ${envResult.reason}` }],
+                        metadata: {},
+                        timestamp: new Date().toISOString(),
+                    },
+                });
+                socket.emit("runner:runComplete", { runId, status: "failed" });
+                return;
+            }
+            // Register run + set relay project so agent_message → relay →
+            // server → FE join-by-runId works the same as for a pipeline.
+            const project = `crew-${sid.slice(-12)}`;
+            setActiveProject(project);
+            socket.emit("runner:registerRun", {
+                runId,
+                project,
+                pipelineName: project,
+            });
+            // Write main.py + config.json to a per-run scratch dir.
+            const runDir = join(tmpdir(), `melaya-crew-${runId}`);
+            mkdirSync(runDir, { recursive: true });
+            writeFileSync(join(runDir, "main.py"), mainPyContent, "utf-8");
+            writeFileSync(join(runDir, "config.json"), JSON.stringify(cfg, null, 2), "utf-8");
+            // Preflight the first persona's model so we surface an early
+            // failure if (e.g.) LM Studio hasn't loaded the requested
+            // qwen3.6-27b. Same flow as pipelines — it just reads the
+            // first model entry from config.json.
+            const { preflightModel } = await import("./modelLoader.js");
+            const preflight = await preflightModel(JSON.stringify(cfg), (msg) => {
+                console.log(chalk.gray(`  [model] ${msg}`));
+                socket.emit("runner:event", {
+                    run_id: runId,
+                    event_type: "pipeline_phase",
+                    project,
+                    step: 2,
+                    total: 5,
+                    label: msg,
+                    status: "started",
+                });
+            });
+            if (!preflight.ok) {
+                const detail = `${preflight.reason ?? "unknown"}${preflight.hint ? ` — ${preflight.hint}` : ""}`;
+                console.log(chalk.red(`  ✗ model preflight failed: ${detail}`));
+                socket.emit("runner:event", {
+                    run_id: runId,
+                    event_type: "agent_message",
+                    project,
+                    replyId: `preflight-${runId}`,
+                    replyName: "Runner",
+                    replyRole: "system",
+                    msg: {
+                        id: `preflight-${runId}`,
+                        name: "Runner",
+                        role: "system",
+                        content: [{ type: "text", text: `Model preflight failed: ${detail}` }],
+                        metadata: {},
+                        timestamp: new Date().toISOString(),
+                    },
+                });
+                socket.emit("runner:runComplete", { runId, status: "failed" });
+                return;
+            }
+            // Build env. Same MEL_MODEL_* scrub + cert bundle wiring as the
+            // pipeline path; on top of that, set the MEL_CREW_* the crew loop
+            // reads (strategy id, cadence, dry-run mode, owner) plus
+            // MEL_OWNER_USER_ID/TIER which the HITL middleware uses for
+            // per-tier quota checks.
+            const sharedDir = getSharedDir();
+            const inherited = { ...process.env };
+            for (const k of Object.keys(inherited)) {
+                if (k.startsWith("MEL_MODEL_"))
+                    delete inherited[k];
+            }
+            const certBundle = (await import("./pythonEnv.js")).getCertBundlePath();
+            const sslEnv = certBundle
+                ? { SSL_CERT_FILE: certBundle, REQUESTS_CA_BUNDLE: certBundle }
+                : {};
+            const env = {
+                ...inherited,
+                PYTHONPATH: sharedDir,
+                PYTHONIOENCODING: "utf-8",
+                PYTHONUTF8: "1",
+                ...sslEnv,
+                MEL_RUN_ID: runId,
+                MEL_STUDIO_URL: opts.serverUrl.replace(/^wss:/, "https:").replace(/^ws:/, "http:"),
+                MEL_BUILDER_URL: `http://127.0.0.1:${relay.port}`,
+                MEL_RELAY_NONCE: relay.nonce,
+                LMSTUDIO_BASE_URL: "http://127.0.0.1:1234",
+                OLLAMA_BASE_URL: "http://127.0.0.1:11434",
+                MEL_CREW_STRATEGY_ID: sid,
+                MEL_CREW_CADENCE_MODE: String(cfg.cadenceMode ?? "hybrid"),
+                MEL_CREW_CADENCE_SECONDS: String(cfg.cadenceSeconds ?? 300),
+                MEL_CREW_DRY_RUN: String(cfg.dryRunMode ?? "paper"),
+                MEL_OWNER_USER_ID: payload.owner_user_id,
+                MEL_OWNER_TIER: payload.owner_tier,
+                MELAYA_OUTPUT_DIR: (() => {
+                    const dir = join(homedir(), "Documents", "Melaya-Pipelines", project, "outputs");
+                    try {
+                        mkdirSync(dir, { recursive: true });
+                    }
+                    catch (e) {
+                        console.log(chalk.yellow(`  ! could not create output dir ${dir}: ${e.message}`));
+                    }
+                    return dir;
+                })(),
+                ...(preflight.profile
+                    ? {
+                        MEL_MODEL_TIER: preflight.profile.tier,
+                        MEL_MODEL_FAMILY: preflight.profile.family ?? "",
+                        MEL_MODEL_PARAMS_B: String(preflight.profile.paramsBillion ?? ""),
+                        MEL_MODEL_MAX_TOKENS: String(preflight.profile.recommendedMaxTokens),
+                        MEL_MODEL_MAX_ITERS: String(preflight.profile.recommendedMaxIters),
+                        MEL_MODEL_DISABLE_THINKING: preflight.profile.thinkingDefault === "off" ? "1" : "0",
+                    }
+                    : {}),
+            };
+            const proc = spawn(envResult.pythonPath, ["-u", join(runDir, "main.py")], {
+                cwd: runDir,
+                env,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            activeProcesses.set(runId, proc);
+            const stderrTail = [];
+            const STDERR_TAIL_MAX = 60;
+            proc.stdout?.on("data", (data) => {
+                const line = data.toString().trim();
+                if (line && opts.verbose)
+                    console.log(chalk.gray(`  [crew-stdout] ${line}`));
+            });
+            proc.stderr?.on("data", (data) => {
+                const text = data.toString();
+                for (const ln of text.split("\n")) {
+                    const t = ln.trimEnd();
+                    if (!t)
+                        continue;
+                    console.log(chalk.yellow(`  [crew-stderr] ${t}`));
+                    stderrTail.push(t);
+                    if (stderrTail.length > STDERR_TAIL_MAX)
+                        stderrTail.shift();
+                }
+            });
+            proc.on("exit", (code) => {
+                activeProcesses.delete(runId);
+                const status = code === 0 ? "done" : "failed";
+                if (status === "failed" && stderrTail.length > 0) {
+                    const tail = stderrTail.slice(-15).join("\n");
+                    socket.emit("runner:event", {
+                        run_id: runId,
+                        event_type: "agent_message",
+                        project,
+                        replyId: `runner-exit-${runId}`,
+                        replyName: "Runner",
+                        replyRole: "system",
+                        msg: {
+                            id: `runner-exit-${runId}`,
+                            name: "Runner",
+                            role: "system",
+                            content: [{
+                                    type: "text",
+                                    text: `Crew exited with code ${code}. Last stderr:\n\`\`\`\n${tail}\n\`\`\``,
+                                }],
+                            metadata: { exitCode: code },
+                            timestamp: new Date().toISOString(),
+                        },
+                    });
+                }
+                socket.emit("runner:event", {
+                    run_id: runId,
+                    event_type: "run_status",
+                    status,
+                    project,
+                });
+                setTimeout(() => {
+                    socket.emit("runner:runComplete", { runId, status });
+                }, 200);
+                console.log(chalk.gray(`  ■ Crew finished (exit ${code})\n`));
+            });
+        }
+        catch (e) {
+            console.log(chalk.red(`  ✗ Crew spawn failed: ${e.message}`));
+            socket.emit("runner:runComplete", { runId: payload.run_id, status: "failed" });
+        }
+    });
     // ── RAG Mode B: local-folder ingest (privacy-preserving) ─────────────
     // The user picks "Local folder" in the Agent Builder DocsTab and types
     // a path on their machine (e.g. C:\Users\me\Documents\refs). The server

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melaya/runner",
-  "version": "1.0.55",
+  "version": "1.0.56",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,