nvent 0.5.15 → 1.0.0-alpha.2

package/dist/runtime/app/composables/useFunctionCall.d.ts

@@ -0,0 +1,17 @@
+/**
+ * useFunctionCall — call a nvent function via the /functions/** proxy.
+ *
+ * ```ts
+ * const { call, pending, data, error } = useFunctionCall('pipeline/start')
+ * const result = await call({ text: 'Hello' })
+ * // result may include a streamId to pass to useNventStream
+ * ```
+ */
+export declare function useFunctionCall<TInput = unknown, TOutput = unknown>(path: string): {
+    pending: import('vue').Ref<boolean>;
+    error: import('vue').Ref<Error | null>;
+    data: import('vue').Ref<TOutput | null>;
+    call: (input?: TInput, options?: {
+        method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    }) => Promise<TOutput>;
+};

package/dist/runtime/app/composables/useFunctionCall.js

@@ -0,0 +1,25 @@
+import { ref } from "vue";
+export function useFunctionCall(path) {
+  const pending = ref(false);
+  const error = ref(null);
+  const data = ref(null);
+  async function call(input, options = {}) {
+    pending.value = true;
+    error.value = null;
+    try {
+      const method = options.method ?? (input !== void 0 ? "POST" : "GET");
+      const result = await $fetch(`/functions/${path}`, {
+        method,
+        ...method === "GET" ? { params: input } : { body: input }
+      });
+      data.value = result;
+      return result;
+    } catch (e) {
+      error.value = e;
+      throw e;
+    } finally {
+      pending.value = false;
+    }
+  }
+  return { call, pending, data, error };
+}

package/dist/runtime/app/composables/useNventStream.d.ts

@@ -0,0 +1,23 @@
+/**
+ * useNventStream — subscribe to an iii stream group via WebSocket.
+ *
+ * The iii stream module serves WebSocket connections at:
+ *   ws://host/stream/{stream_name}/{group_id}/
+ *
+ * Nitro proxies `/stream/**` → `ws://iii-engine:3112/stream/**`, so connecting
+ * to the current page host is sufficient — no hardcoded ports needed.
+ *
+ * ```ts
+ * const { messages, status, subscribe, close } = useNventStream<MyEvent>()
+ * subscribe('pipeline', jobId)   // start listening
+ * // messages.value grows as events arrive
+ * ```
+ */
+import { ref } from 'vue';
+export type NventStreamStatus = 'idle' | 'connecting' | 'connected' | 'closed' | 'error';
+export declare function useNventStream<TMessage = unknown>(): {
+    messages: ReturnType<typeof ref<TMessage[]>>;
+    status: import("vue").Ref<NventStreamStatus, NventStreamStatus>;
+    subscribe: (streamName: string, groupId: string) => void;
+    close: () => void;
+};

package/dist/runtime/app/composables/useNventStream.js

@@ -0,0 +1,58 @@
+import { ref, onUnmounted } from "vue";
+export function useNventStream() {
+  const messages = ref([]);
+  const status = ref("idle");
+  let ws = null;
+  function subscribe(streamName, groupId) {
+    close();
+    messages.value = [];
+    status.value = "connecting";
+    const protocol = typeof window !== "undefined" && window.location.protocol === "https:" ? "wss:" : "ws:";
+    const host = typeof window !== "undefined" ? window.location.host : "localhost";
+    ws = new WebSocket(`${protocol}//${host}/stream/${streamName}/${groupId}/`);
+    ws.onopen = () => {
+      status.value = "connected";
+    };
+    ws.onmessage = (e) => {
+      try {
+        const envelope = JSON.parse(e.data);
+        let payload;
+        if (envelope?.event?.type === "event") {
+          payload = envelope.event.event;
+        } else if (envelope?.event?.data !== void 0) {
+          payload = envelope.event.data;
+        } else {
+          payload = envelope;
+        }
+        if (Array.isArray(payload)) {
+          messages.value = [...messages.value, ...payload];
+        } else {
+          messages.value = [...messages.value, payload];
+        }
+      } catch {
+        messages.value = [...messages.value, e.data];
+      }
+    };
+    ws.onerror = () => {
+      status.value = "error";
+    };
+    ws.onclose = () => {
+      if (status.value !== "error") status.value = "closed";
+      ws = null;
+    };
+  }
+  function close() {
+    if (ws) {
+      ws.close();
+      ws = null;
+      status.value = "closed";
+    }
+  }
+  onUnmounted(close);
+  return {
+    messages,
+    status,
+    subscribe,
+    close
+  };
+}

package/dist/runtime/nitro/plugins/00.iii-lifecycle.d.ts

@@ -0,0 +1,19 @@
+/**
+ * iii Lifecycle Plugin
+ *
+ * Manages the iii engine and console process lifecycle at **server runtime**.
+ *
+ * - **Development**: no-op. The Nuxt module (module.ts) starts engine + console
+ *   in the parent Nuxt process so they survive Nitro hot-reloads naturally.
+ * - **Production** (`managed: true`, `mode: 'local'`): starts engine + console here.
+ *
+ * Binaries and iii-config.yaml are placed by `nuxt build` (module.ts) into
+ * `.output/nvent/`. The plugin finds them by walking up from import.meta.url —
+ * this is CWD-independent and works when .output/ is copied or deployed elsewhere.
+ *
+ * This plugin does NOT download anything — it finds what build already placed.
+ *
+ * Worker registration (Node.js + Python) is handled by 00.iii-worker.ts.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/nitro/plugins/00.iii-lifecycle.js

@@ -0,0 +1,62 @@
+import { defineNitroPlugin, useRuntimeConfig } from "#imports";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createEngineManager } from "../utils/engine.js";
+import { ConsoleManager } from "../utils/console.js";
+import { resolveNventDir } from "../utils/nventDir.js";
+function findExisting(...candidates) {
+  return candidates.find((p) => existsSync(p));
+}
+export default defineNitroPlugin(async (nitroApp) => {
+  const rc = useRuntimeConfig();
+  const cfg = rc.nvent ?? {};
+  const iiiCfg = cfg.iii ?? {};
+  if (!iiiCfg.managed) return;
+  if ((iiiCfg.mode ?? "local") !== "local") return;
+  if (process.env.NODE_ENV === "development") return;
+  const httpPort = iiiCfg.httpPort ?? 3111;
+  const wsPort = iiiCfg.wsPort ?? 49134;
+  const logLevel = iiiCfg.logLevel ?? "warn";
+  const binaryName = process.platform === "win32" ? "iii.exe" : "iii";
+  const nventDir = resolveNventDir(import.meta.url);
+  const binDir = join(nventDir, "bin");
+  const binaryPath = findExisting(join(binDir, binaryName));
+  if (!binaryPath) {
+    console.error("[nvent] iii engine binary not found. Run `nuxt build` to install it.");
+    return;
+  }
+  let configPath = findExisting(join(nventDir, "iii-config.yaml"));
+  if (!configPath) {
+    if (!iiiCfg.engineConfigYaml) {
+      console.error("[nvent] iii-config.yaml not found and no stored config available. Skipping engine start.");
+      return;
+    }
+    mkdirSync(nventDir, { recursive: true });
+    configPath = join(nventDir, "iii-config.yaml");
+    writeFileSync(configPath, iiiCfg.engineConfigYaml, "utf-8");
+  }
+  const engine = createEngineManager({ binaryPath, configPath, httpPort, wsPort, logLevel });
+  await engine.start();
+  let consoleManager = null;
+  if (cfg.console?.enabled) {
+    const consoleBinaryName = process.platform === "win32" ? "iii-console.exe" : "iii-console";
+    const consoleBinPath = findExisting(join(binDir, consoleBinaryName));
+    if (consoleBinPath) {
+      consoleManager = new ConsoleManager({
+        binaryPath: consoleBinPath,
+        port: cfg.console.port ?? 3113,
+        enginePort: httpPort,
+        bridgePort: wsPort,
+        flow: cfg.console.flow ?? true,
+        logLevel
+      });
+      await consoleManager.start();
+    } else {
+      console.warn("[nvent] iii-console binary not found \u2014 console UI will not start.");
+    }
+  }
+  nitroApp.hooks.hookOnce("close", async () => {
+    await consoleManager?.stop();
+    await engine.stop();
+  });
+});

package/dist/runtime/nitro/plugins/01.iii-worker.d.ts

@@ -0,0 +1,15 @@
+/**
+ * iii Worker Plugin
+ *
+ * Unified worker plugin — connects Nitro to the running iii engine and manages
+ * all worker types: Node.js (TypeScript) and Python (and future runtimes).
+ * The iii instance is stored on nitroApp so consumers can reach it via useIii().
+ */
+import { registerWorker } from 'iii-sdk';
+declare module 'nitropack' {
+    interface NitroApp {
+        $iii: ReturnType<typeof registerWorker>;
+    }
+}
+declare const _default: any;
+export default _default;

package/dist/runtime/nitro/plugins/01.iii-worker.js

@@ -0,0 +1,91 @@
+import { defineNitroPlugin, useRuntimeConfig } from "#imports";
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { resolveNventDir } from "../utils/nventDir.js";
+import { registerWorker } from "iii-sdk";
+import { registerNodeFunctions } from "../utils/workers/node.js";
+import { PythonWorkersOrchestrator } from "../utils/workers/python.js";
+import { registry, pythonFunctions } from "#nvent/iii-registry";
+function readProjectName() {
+  try {
+    const pkgPath = join(process.cwd(), "package.json");
+    if (!existsSync(pkgPath)) return void 0;
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return typeof pkg.name === "string" ? pkg.name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+export default defineNitroPlugin(async (nitroApp) => {
+  const runtimeConfig = useRuntimeConfig();
+  const nventCfg = runtimeConfig.nvent ?? {};
+  const cfg = nventCfg.iii ?? {};
+  const pythonCfg = nventCfg.python ?? {};
+  const wsUrl = cfg.wsUrl ?? process.env.III_BRIDGE_URL ?? "ws://localhost:49134";
+  const logLevel = cfg.logLevel ?? "warn";
+  const pythonBin = (() => {
+    const raw = process.env.NVENT_PYTHON_BIN ?? "python3";
+    if (!raw || raw === "python3" || raw === "python" || isAbsolute(raw)) return raw;
+    const roots = [
+      process.cwd(),
+      join(process.cwd(), ".."),
+      join(process.cwd(), "..", ".."),
+      join(process.cwd(), "..", "..", ".."),
+      process.env.NVENT_DIR ? join(process.env.NVENT_DIR, "..") : null
+    ].filter(Boolean);
+    for (const root of roots) {
+      const candidate = resolve(root, raw);
+      if (existsSync(candidate)) return candidate;
+    }
+    return raw;
+  })();
+  const workerName = cfg.workerName ?? `nvent-${process.pid}`;
+  const fnCount = (registry.functions ?? []).length;
+  const triggerCount = (registry.triggers ?? []).length;
+  console.log(`[nvent] iii-worker: connecting to ${wsUrl} \u2014 ${fnCount} function(s), ${triggerCount} trigger(s)`);
+  const iii = registerWorker(wsUrl, {
+    workerName,
+    otel: {
+      enabled: true,
+      serviceName: "nvent",
+      metricsExportIntervalMs: 1e4
+    },
+    telemetry: {
+      framework: "nvent",
+      project_name: readProjectName()
+    },
+    reconnectionConfig: {
+      initialDelayMs: 500,
+      maxDelayMs: 15e3,
+      maxRetries: -1
+    }
+  });
+  console.log(`[nvent] iii-worker: connected to engine (worker: ${workerName})`);
+  registerNodeFunctions(iii, registry.functions ?? []);
+  nitroApp.$iii = iii;
+  const nventArtifactsDir = resolveNventDir(import.meta.url);
+  const workersDir = join(nventArtifactsDir, "workers");
+  const runtimeFilePath = join(workersDir, "_runtime.py");
+  const nventHelperFilePath = join(workersDir, "nvent.py");
+  const runtimeContent = existsSync(runtimeFilePath) ? readFileSync(runtimeFilePath, "utf-8") : pythonCfg.runtimeContent ?? "";
+  const nventHelperContent = existsSync(nventHelperFilePath) ? readFileSync(nventHelperFilePath, "utf-8") : pythonCfg.nventHelperContent ?? "";
+  const orchestrator = new PythonWorkersOrchestrator(
+    workersDir,
+    runtimeContent,
+    nventHelperContent,
+    wsUrl,
+    pythonBin,
+    logLevel
+  );
+  if (process.env.NODE_ENV !== "development" && !pythonCfg.skip) {
+    const resolvedPythonFunctions = (pythonFunctions ?? []).map((fn) => ({
+      ...fn,
+      absPath: isAbsolute(fn.absPath) ? fn.absPath : join(nventArtifactsDir, "functions", fn.absPath)
+    }));
+    await orchestrator.start(resolvedPythonFunctions);
+  }
+  nitroApp.hooks.hookOnce("close", async () => {
+    await orchestrator.stop();
+    await iii.shutdown();
+  });
+});

package/dist/runtime/nitro/routes/stream-proxy.d.ts

@@ -0,0 +1,17 @@
+/**
+ * WebSocket proxy for the iii Stream module.
+ *
+ * The iii stream module listens on its own port (default 3112) and only accepts
+ * connections at the root path `ws://host:3112/`. After connecting, the client
+ * must send a join message to subscribe to a stream group:
+ *
+ *   { type: 'join', data: { streamName, groupId, subscriptionId } }
+ *
+ * This handler matches `/stream/{streamName}/{groupId}[/]` on the Nuxt/Nitro
+ * side, extracts the stream name and group ID from the URL path, connects to
+ * the upstream root, sends the join message, and then transparently bridges
+ * all subsequent messages so the browser never needs to know about port 3112
+ * or the join protocol.
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, never>;
+export default _default;

package/dist/runtime/nitro/routes/stream-proxy.js

@@ -0,0 +1,45 @@
+import { defineWebSocketHandler } from "h3";
+export default defineWebSocketHandler({
+  open(peer) {
+    const { nvent } = useRuntimeConfig();
+    const host = nvent.iii.httpHost;
+    const port = nvent.iii.streamPort;
+    const rawUrl = peer.request.url;
+    const pathname = rawUrl.startsWith("http") ? new URL(rawUrl).pathname : rawUrl.split("?")[0];
+    const parts = pathname.replace(/^\/stream\//, "").replace(/\/$/, "").split("/");
+    const streamName = parts[0] ?? "";
+    const groupId = parts[1] ?? "";
+    const upstreamUrl = `ws://${host}:${port}/`;
+    const upstream = new WebSocket(upstreamUrl);
+    peer.context._upstream = upstream;
+    upstream.addEventListener("open", () => {
+      const subscriptionId = crypto.randomUUID();
+      upstream.send(JSON.stringify({
+        type: "join",
+        data: { streamName, groupId, subscriptionId }
+      }));
+    });
+    upstream.addEventListener("message", (e) => {
+      peer.send(typeof e.data === "string" ? e.data : JSON.stringify(e.data));
+    });
+    upstream.addEventListener("close", (e) => {
+      peer.close(e.code, e.reason);
+    });
+    upstream.addEventListener("error", () => {
+      peer.close(1011, "Upstream stream error");
+    });
+  },
+  message(peer, message) {
+    const upstream = peer.context._upstream;
+    if (upstream?.readyState === WebSocket.OPEN) {
+      upstream.send(message.rawData);
+    }
+  },
+  close(peer) {
+    const upstream = peer.context._upstream;
+    if (upstream && upstream.readyState < WebSocket.CLOSING) {
+      upstream.close();
+    }
+    delete peer.context._upstream;
+  }
+});

package/dist/runtime/nitro/utils/console.d.ts

@@ -0,0 +1,32 @@
+/**
+ * iii Console Process Manager — runtime util
+ *
+ * Manages the lifecycle of the iii-console process.
+ * Lives in src/runtime/nitro/utils/ so it is bundled into the Nitro output.
+ * Binary installation is handled separately by ensureIiiConsole in src/iii/console.ts.
+ */
+export interface ConsoleManagerOptions {
+    binaryPath: string;
+    /** Port for the console web UI. Default: 3113 */
+    port?: number;
+    /** Engine HTTP API host. Default: 127.0.0.1 */
+    engineHost?: string;
+    /** Engine HTTP port. Default: 3111 */
+    enginePort?: number;
+    /** Engine WebSocket port. Default: 3112 */
+    wsPort?: number;
+    /** SDK bridge port. Default: 49134 */
+    bridgePort?: number;
+    /** Enable the Flow visualization page. Default: true */
+    flow?: boolean;
+    /** Minimum log level for console process output. Default: 'warn' */
+    logLevel?: 'none' | 'error' | 'warn' | 'info';
+}
+export declare class ConsoleManager {
+    private process;
+    private readonly opts;
+    constructor(opts: ConsoleManagerOptions);
+    isRunning(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/runtime/nitro/utils/console.js

@@ -0,0 +1,95 @@
+import { spawn } from "node:child_process";
+import { consola } from "consola";
+const logger = consola.withTag("nvent:console");
+function parseConsoleLineLevel(line) {
+  if (line.includes(" ERROR ") || line.includes("[ERROR]")) return "error";
+  if (line.includes(" WARN ") || line.includes("[WARN]")) return "warn";
+  if (line.includes(" INFO ") || line.includes("[INFO]")) return "info";
+  return null;
+}
+const LOG_LEVEL_RANK = { none: 0, error: 1, warn: 2, info: 3 };
+function shouldShow(lineLevel, minLevel) {
+  return LOG_LEVEL_RANK[lineLevel] <= LOG_LEVEL_RANK[minLevel];
+}
+export class ConsoleManager {
+  process = null;
+  opts;
+  constructor(opts) {
+    this.opts = {
+      port: 3113,
+      engineHost: "127.0.0.1",
+      enginePort: 3111,
+      wsPort: 3112,
+      bridgePort: 49134,
+      flow: true,
+      logLevel: "warn",
+      ...opts
+    };
+  }
+  isRunning() {
+    return this.process !== null && !this.process.killed && this.process.exitCode === null;
+  }
+  async start() {
+    if (this.isRunning()) {
+      logger.warn("iii-console is already running");
+      return;
+    }
+    const { binaryPath, port, engineHost, enginePort, wsPort, bridgePort, flow, logLevel } = this.opts;
+    const args = [
+      "--port",
+      String(port),
+      "--engine-host",
+      engineHost,
+      "--engine-port",
+      String(enginePort),
+      "--ws-port",
+      String(wsPort),
+      "--bridge-port",
+      String(bridgePort)
+    ];
+    if (flow) args.push("--enable-flow");
+    if (logLevel === "info") logger.info(`Starting iii-console on http://localhost:${port}`);
+    this.process = spawn(binaryPath, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false
+    });
+    this.process.stdout?.on("data", (chunk) => {
+      if (logLevel === "none") return;
+      for (const line of chunk.toString().split("\n").filter(Boolean)) {
+        const level = parseConsoleLineLevel(line) ?? "info";
+        if (!shouldShow(level, logLevel)) continue;
+        if (level === "error") logger.error(`[console] ${line}`);
+        else if (level === "warn") logger.warn(`[console] ${line}`);
+        else logger.info(`[console] ${line}`);
+      }
+    });
+    this.process.stderr?.on("data", (chunk) => {
+      if (logLevel === "none") return;
+      for (const line of chunk.toString().split("\n").filter(Boolean))
+        logger.warn(`[console] ${line}`);
+    });
+    this.process.on("exit", (code, signal) => {
+      if (logLevel === "info") logger.info(`iii-console exited (code=${code}, signal=${signal})`);
+      this.process = null;
+    });
+    this.process.on("error", (err) => {
+      logger.error(`iii-console process error: ${err.message}`);
+      this.process = null;
+    });
+  }
+  async stop() {
+    if (!this.isRunning() || !this.process) return;
+    const { logLevel } = this.opts;
+    return new Promise((resolve) => {
+      this.process.once("exit", () => {
+        this.process = null;
+        if (logLevel === "info") logger.info("iii-console stopped");
+        resolve();
+      });
+      this.process.kill("SIGTERM");
+      setTimeout(() => {
+        if (this.process) this.process.kill("SIGKILL");
+      }, 5e3);
+    });
+  }
+}