@getvision/server 0.4.3-d4c761e-develop → 0.4.4-44d79d9-develop

package/dist/vision-app.js

@@ -0,0 +1,611 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/vision-app.ts
+import { Hono } from "hono";
+import { VisionCore, runInTraceContext } from "@getvision/core";
+import { AsyncLocalStorage } from "async_hooks";
+import { existsSync } from "fs";
+import { spawn, spawnSync } from "child_process";
+import { ServiceBuilder } from "./service";
+import { EventBus } from "./event-bus";
+import { eventRegistry } from "./event-registry";
+var visionContext = new AsyncLocalStorage;
+var GLOBAL_VISION_KEY = "__vision_instance_state";
+if (!globalThis[GLOBAL_VISION_KEY]) {
+  globalThis[GLOBAL_VISION_KEY] = {
+    instance: null,
+    drizzleProcess: null
+  };
+}
+function getGlobalState() {
+  return globalThis[GLOBAL_VISION_KEY];
+}
+async function cleanupVisionInstance(instance) {
+  const existing = instance._cleanupPromise;
+  if (existing)
+    return existing;
+  instance._cleanupPromise = (async () => {
+    const server = instance.bunServer;
+    const hasBunServer = server && typeof server.stop === "function";
+    try {
+      if (hasBunServer) {
+        server.stop();
+      }
+      if (globalThis.__vision_bun_server === server) {
+        globalThis.__vision_bun_server = undefined;
+      }
+    } catch {}
+    try {
+      stopDrizzleStudio({ log: false });
+    } catch {}
+    try {
+      await instance.eventBus?.close();
+    } catch {}
+  })();
+  return instance._cleanupPromise;
+}
+function deepMerge(target, source) {
+  const output = { ...target };
+  if (source && typeof source === "object") {
+    for (const key of Object.keys(source)) {
+      const srcVal = source[key];
+      const tgtVal = output[key];
+      if (srcVal && typeof srcVal === "object" && !Array.isArray(srcVal) && tgtVal && typeof tgtVal === "object" && !Array.isArray(tgtVal)) {
+        output[key] = deepMerge(tgtVal, srcVal);
+      } else {
+        output[key] = srcVal;
+      }
+    }
+  }
+  return output;
+}
+
+class Vision extends Hono {
+  visionCore;
+  eventBus;
+  config;
+  serviceBuilders = [];
+  bunServer;
+  signalHandler;
+  constructor(config) {
+    super();
+    const defaultConfig = {
+      service: {
+        name: "Vision SubApp"
+      },
+      vision: {
+        enabled: false,
+        port: 9500
+      },
+      pubsub: {},
+      routes: {
+        autodiscover: true,
+        dirs: ["app/routes"]
+      }
+    };
+    this.config = deepMerge(defaultConfig, config || {});
+    const visionEnabled = this.config.vision?.enabled !== false;
+    const visionPort = this.config.vision?.port ?? 9500;
+    if (visionEnabled) {
+      this.visionCore = new VisionCore({
+        port: visionPort,
+        maxTraces: this.config.vision?.maxTraces ?? 1000,
+        maxLogs: this.config.vision?.maxLogs ?? 1e4,
+        apiUrl: this.config.vision?.apiUrl
+      });
+      const drizzleInfo = detectDrizzle();
+      let drizzleStudioUrl;
+      if (drizzleInfo.detected) {
+        console.log(`\uD83D\uDDC4️  Drizzle detected (${drizzleInfo.configPath})`);
+        if (this.config.service.drizzle?.autoStart) {
+          const drizzlePort = this.config.service.drizzle.port || 4983;
+          const started = startDrizzleStudio(drizzlePort);
+          if (started) {
+            drizzleStudioUrl = "https://local.drizzle.studio";
+          }
+        } else {
+          console.log("\uD83D\uDCA1 Tip: Enable Drizzle Studio auto-start with drizzle: { autoStart: true }");
+          drizzleStudioUrl = "https://local.drizzle.studio";
+        }
+      }
+      const cleanIntegrations = Object.fromEntries(Object.entries(this.config.service.integrations || {}).filter(([_, v]) => v !== undefined));
+      this.visionCore.setAppStatus({
+        name: this.config.service.name,
+        version: this.config.service.version ?? "0.0.0",
+        description: this.config.service.description,
+        running: true,
+        pid: process.pid,
+        metadata: {
+          framework: "vision-server",
+          integrations: Object.keys(cleanIntegrations).length > 0 ? cleanIntegrations : undefined,
+          drizzle: drizzleInfo.detected ? {
+            detected: true,
+            configPath: drizzleInfo.configPath,
+            studioUrl: drizzleStudioUrl,
+            autoStarted: this.config.service.drizzle?.autoStart || false
+          } : {
+            detected: false,
+            configPath: undefined,
+            studioUrl: undefined,
+            autoStarted: false
+          }
+        }
+      });
+    } else {
+      this.visionCore = null;
+    }
+    this.eventBus = this.config.pubsub?.eventBus || new EventBus({
+      redis: this.config.pubsub?.redis,
+      devMode: this.config.pubsub?.devMode,
+      workerConcurrency: this.config.pubsub?.workerConcurrency,
+      queue: this.config.pubsub?.queue,
+      worker: this.config.pubsub?.worker,
+      queueEvents: this.config.pubsub?.queueEvents
+    });
+    if (visionEnabled) {
+      this.registerEventMethods();
+    }
+    if (visionEnabled) {
+      this.installVisionMiddleware();
+    }
+  }
+  registerEventMethods() {
+    const server = this.visionCore.getServer();
+    server.registerMethod("events/list", async () => {
+      const events = eventRegistry.getAllEvents();
+      return events.map((event) => ({
+        name: event.name,
+        description: event.description,
+        icon: event.icon,
+        tags: event.tags,
+        handlers: event.handlers.length,
+        lastTriggered: event.lastTriggered,
+        totalCount: event.totalCount,
+        failedCount: event.failedCount
+      }));
+    });
+    server.registerMethod("cron/list", async () => {
+      const crons = eventRegistry.getAllCrons();
+      return crons.map((cron) => ({
+        name: cron.name,
+        schedule: cron.schedule,
+        description: cron.description,
+        icon: cron.icon,
+        tags: cron.tags,
+        lastRun: cron.lastRun,
+        nextRun: cron.nextRun,
+        totalRuns: cron.totalRuns,
+        failedRuns: cron.failedRuns
+      }));
+    });
+  }
+  installVisionMiddleware() {
+    const logging = this.config.vision?.logging !== false;
+    this.use("*", async (c, next) => {
+      if (c.req.method === "OPTIONS") {
+        return next();
+      }
+      const startTime = Date.now();
+      const trace = this.visionCore.createTrace(c.req.method, c.req.path);
+      return visionContext.run({
+        vision: this.visionCore,
+        traceId: trace.id,
+        rootSpanId: ""
+      }, async () => {
+        return runInTraceContext(trace.id, async () => {
+          const tracer = this.visionCore.getTracer();
+          const rootSpan = tracer.startSpan("http.request", trace.id);
+          const ctx = visionContext.getStore();
+          if (ctx) {
+            ctx.rootSpanId = rootSpan.id;
+          }
+          if (!c.span) {
+            c.addContext = (context) => {
+              const current = visionContext.getStore();
+              const currentTraceId = current?.traceId || trace.id;
+              const visionTrace = this.visionCore.getTraceStore().getTrace(currentTraceId);
+              if (visionTrace) {
+                visionTrace.metadata = { ...visionTrace.metadata || {}, ...context };
+              }
+            };
+            c.span = (name, attributes = {}, fn) => {
+              const current = visionContext.getStore();
+              const currentTraceId = current?.traceId || trace.id;
+              const currentRootSpanId = current?.rootSpanId || rootSpan.id;
+              const s = tracer.startSpan(name, currentTraceId, currentRootSpanId);
+              for (const [k, v] of Object.entries(attributes))
+                tracer.setAttribute(s.id, k, v);
+              try {
+                const result = fn ? fn() : undefined;
+                const completed = tracer.endSpan(s.id);
+                if (completed)
+                  this.visionCore.getTraceStore().addSpan(currentTraceId, completed);
+                return result;
+              } catch (err) {
+                tracer.setAttribute(s.id, "error", true);
+                tracer.setAttribute(s.id, "error.message", err instanceof Error ? err.message : String(err));
+                const completed = tracer.endSpan(s.id);
+                if (completed)
+                  this.visionCore.getTraceStore().addSpan(currentTraceId, completed);
+                throw err;
+              }
+            };
+          }
+          tracer.setAttribute(rootSpan.id, "http.method", c.req.method);
+          tracer.setAttribute(rootSpan.id, "http.path", c.req.path);
+          tracer.setAttribute(rootSpan.id, "http.url", c.req.url);
+          const url = new URL(c.req.url);
+          if (url.search) {
+            tracer.setAttribute(rootSpan.id, "http.query", url.search);
+          }
+          try {
+            const rawReq = c.req.raw;
+            const headers = {};
+            rawReq.headers.forEach((v, k) => {
+              headers[k] = v;
+            });
+            const urlObj = new URL(c.req.url);
+            const query = {};
+            urlObj.searchParams.forEach((v, k) => {
+              query[k] = v;
+            });
+            let body = undefined;
+            const ct = headers["content-type"] || headers["Content-Type"];
+            if (ct && ct.includes("application/json")) {
+              try {
+                body = await rawReq.clone().json();
+              } catch {}
+            }
+            const sessionId = headers["x-vision-session"];
+            if (sessionId) {
+              tracer.setAttribute(rootSpan.id, "session.id", sessionId);
+              trace.metadata = { ...trace.metadata || {}, sessionId };
+            }
+            const requestMeta = {
+              method: c.req.method,
+              url: urlObj.pathname + (urlObj.search || ""),
+              headers,
+              query: Object.keys(query).length ? query : undefined,
+              body
+            };
+            tracer.setAttribute(rootSpan.id, "http.request", requestMeta);
+            trace.metadata = { ...trace.metadata || {}, request: requestMeta };
+            if (logging) {
+              const parts = [
+                `method=${c.req.method}`,
+                `path=${c.req.path}`
+              ];
+              if (sessionId)
+                parts.push(`sessionId=${sessionId}`);
+              parts.push(`traceId=${trace.id}`);
+              console.info(`INF starting request ${parts.join(" ")}`);
+            }
+            await next();
+            tracer.setAttribute(rootSpan.id, "http.status_code", c.res.status);
+            const resHeaders = {};
+            c.res.headers?.forEach((v, k) => {
+              resHeaders[k] = v;
+            });
+            let respBody = undefined;
+            const resCt = c.res.headers?.get("content-type") || "";
+            try {
+              const clone = c.res.clone();
+              if (resCt.includes("application/json")) {
+                const txt = await clone.text();
+                if (txt && txt.length <= 65536) {
+                  try {
+                    respBody = JSON.parse(txt);
+                  } catch {
+                    respBody = txt;
+                  }
+                }
+              }
+            } catch {}
+            const responseMeta = {
+              status: c.res.status,
+              headers: Object.keys(resHeaders).length ? resHeaders : undefined,
+              body: respBody
+            };
+            tracer.setAttribute(rootSpan.id, "http.response", responseMeta);
+            trace.metadata = { ...trace.metadata || {}, response: responseMeta };
+          } catch (error) {
+            tracer.addEvent(rootSpan.id, "error", {
+              message: error instanceof Error ? error.message : "Unknown error",
+              stack: error instanceof Error ? error.stack : undefined
+            });
+            tracer.setAttribute(rootSpan.id, "error", true);
+            throw error;
+          } finally {
+            const completedSpan = tracer.endSpan(rootSpan.id);
+            if (completedSpan) {
+              this.visionCore.getTraceStore().addSpan(trace.id, completedSpan);
+            }
+            const duration = Date.now() - startTime;
+            this.visionCore.completeTrace(trace.id, c.res.status, duration);
+            c.header("X-Vision-Trace-Id", trace.id);
+            if (logging) {
+              console.info(`INF request completed code=${c.res.status} duration=${duration}ms method=${c.req.method} path=${c.req.path} traceId=${trace.id}`);
+            }
+          }
+        });
+      });
+    });
+  }
+  service(name) {
+    const builder = new ServiceBuilder(name, this.eventBus, this.visionCore);
+    this.serviceBuilders.push(builder);
+    return builder;
+  }
+  getServiceSummaries() {
+    const summaries = [];
+    for (const builder of this.serviceBuilders) {
+      const name = builder.getDisplayName?.() ?? "Service";
+      const rawRoutes = builder.getRoutesMetadata?.();
+      if (!rawRoutes || !Array.isArray(rawRoutes))
+        continue;
+      const routes = rawRoutes.map((r) => ({
+        method: r.method,
+        path: r.path,
+        handler: name,
+        queryParams: r.queryParams,
+        requestBody: r.requestBody,
+        responseBody: r.responseBody
+      }));
+      summaries.push({ name, routes });
+    }
+    return summaries;
+  }
+  buildAllServices() {
+    const allServices = [];
+    for (const builder of this.serviceBuilders) {
+      builder.build(this, allServices);
+    }
+    return allServices;
+  }
+  getVision() {
+    return this.visionCore;
+  }
+  getEventBus() {
+    return this.eventBus;
+  }
+  async autoloadRoutes() {
+    const enabled = this.config.routes?.autodiscover !== false;
+    const dirs = this.config.routes?.dirs ?? ["app/routes"];
+    if (!enabled)
+      return [];
+    const existing = [];
+    for (const d of dirs) {
+      try {
+        if (existsSync(d))
+          existing.push(d);
+      } catch {}
+    }
+    if (existing.length === 0)
+      return [];
+    const { loadSubApps } = await import("./router");
+    let allSubAppSummaries = [];
+    for (const d of existing) {
+      try {
+        const summaries = await loadSubApps(this, d, this.eventBus);
+        allSubAppSummaries = allSubAppSummaries.concat(summaries);
+      } catch (e) {
+        console.error(`❌ Failed to load sub-apps from ${d}:`, e?.message || e);
+        if (e instanceof Error && e.stack) {
+          console.error("Stack:", e.stack);
+        }
+      }
+    }
+    return allSubAppSummaries;
+  }
+  async start(port = 3000, options) {
+    const { hostname, ...restOptions } = options || {};
+    const { fetch: _bf, port: _bp, ...bunRest } = restOptions;
+    const { fetch: _nf, port: _np, ...nodeRest } = restOptions;
+    const rootSummaries = this.buildAllServices();
+    const subAppSummaries = await this.autoloadRoutes();
+    const allServices = new Map;
+    for (const summary of rootSummaries || []) {
+      allServices.set(summary.name, { name: summary.name, routes: [...summary.routes] });
+    }
+    for (const summary of subAppSummaries || []) {
+      if (allServices.has(summary.name)) {
+        const existing = allServices.get(summary.name);
+        existing.routes.push(...summary.routes);
+      } else {
+        allServices.set(summary.name, { name: summary.name, routes: [...summary.routes] });
+      }
+    }
+    if (this.visionCore && allServices.size > 0) {
+      const servicesToRegister = Array.from(allServices.values());
+      this.visionCore.registerServices(servicesToRegister);
+      const flatRoutes = servicesToRegister.flatMap((s) => s.routes);
+      this.visionCore.registerRoutes(flatRoutes);
+      console.log(`✅ Registered ${servicesToRegister.length} total services (${flatRoutes.length} routes)`);
+    }
+    const state = getGlobalState();
+    if (state.instance && state.instance !== this) {
+      await cleanupVisionInstance(state.instance);
+    }
+    state.instance = this;
+    console.log(`\uD83D\uDE80 Starting ${this.config.service.name}...`);
+    console.log(`\uD83D\uDCE1 API Server: http://localhost:${port}`);
+    if (!this.signalHandler) {
+      this.signalHandler = async () => {
+        const s = getGlobalState();
+        if (s.instance) {
+          await cleanupVisionInstance(s.instance);
+        }
+        try {
+          process.exit(0);
+        } catch {}
+      };
+    }
+    const handleSignal = this.signalHandler;
+    process.removeListener("SIGINT", handleSignal);
+    process.removeListener("SIGTERM", handleSignal);
+    try {
+      process.removeListener("SIGQUIT", handleSignal);
+    } catch {}
+    process.on("SIGINT", handleSignal);
+    process.on("SIGTERM", handleSignal);
+    try {
+      process.on("SIGQUIT", handleSignal);
+    } catch {}
+    try {
+      const hot = import.meta?.hot;
+      if (hot && typeof hot.dispose === "function") {
+        hot.dispose(async () => {
+          console.log("♻️ Hot reload: reloading...");
+          process.off("SIGINT", handleSignal);
+          process.off("SIGTERM", handleSignal);
+          try {
+            process.off("SIGQUIT", handleSignal);
+          } catch {}
+          const s = getGlobalState();
+          await cleanupVisionInstance(this);
+          if (s.instance === this) {
+            s.instance = null;
+          }
+        });
+      }
+    } catch {}
+    if (typeof process !== "undefined" && process.versions?.bun) {
+      const BunServe = globalThis.Bun?.serve;
+      if (typeof BunServe === "function") {
+        try {
+          const existing = globalThis.__vision_bun_server;
+          if (existing && typeof existing.stop === "function") {
+            try {
+              existing.stop();
+            } catch {}
+          }
+        } catch {}
+        this.bunServer = BunServe({
+          ...bunRest,
+          fetch: this.fetch.bind(this),
+          port,
+          hostname
+        });
+        try {
+          globalThis.__vision_bun_server = this.bunServer;
+        } catch {}
+      } else {
+        console.warn("Bun detected but Bun.serve is unavailable");
+        return this;
+      }
+    } else if (typeof process !== "undefined" && process.versions?.node) {
+      const { serve } = await import("@hono/node-server");
+      serve({
+        ...nodeRest,
+        fetch: this.fetch.bind(this),
+        port,
+        hostname
+      });
+    } else {
+      console.log("⚠️  Use your runtime's serve function");
+      return this;
+    }
+  }
+  setEventBus(eventBus) {
+    this.eventBus = eventBus;
+  }
+}
+function getVisionContext() {
+  return visionContext.getStore();
+}
+function detectDrizzle() {
+  const possiblePaths = [
+    "drizzle.config.ts",
+    "drizzle.config.js",
+    "drizzle.config.mjs"
+  ];
+  for (const path of possiblePaths) {
+    if (existsSync(path)) {
+      return { detected: true, configPath: path };
+    }
+  }
+  return { detected: false };
+}
+function startDrizzleStudio(port) {
+  const state = getGlobalState();
+  if (state.drizzleProcess) {
+    console.log("⚠️  Drizzle Studio is already running");
+    return false;
+  }
+  try {
+    if (process.platform === "win32") {
+      const res = spawnSync("powershell", ["-NoProfile", "-Command", `netstat -ano | Select-String -Pattern "LISTENING\\s+.*:${port}\\s"`], { encoding: "utf-8" });
+      if ((res.stdout || "").trim().length > 0) {
+        console.log(`⚠️  Drizzle Studio port ${port} already in use; assuming it is running. Skipping auto-start.`);
+        return true;
+      }
+    } else {
+      const res = spawnSync("lsof", ["-i", `tcp:${port}`, "-sTCP:LISTEN"], { encoding: "utf-8" });
+      if ((res.stdout || "").trim().length > 0) {
+        console.log(`⚠️  Drizzle Studio port ${port} already in use; assuming it is running. Skipping auto-start.`);
+        return true;
+      }
+    }
+  } catch {}
+  try {
+    const proc = spawn("npx", ["drizzle-kit", "studio", "--port", String(port), "--host", "0.0.0.0"], {
+      stdio: "inherit",
+      detached: false,
+      shell: process.platform === "win32"
+    });
+    state.drizzleProcess = proc;
+    proc.on("error", (error) => {
+      console.error("❌ Failed to start Drizzle Studio:", error.message);
+    });
+    proc.on("exit", (code) => {
+      if (code !== 0 && code !== null) {
+        console.error(`❌ Drizzle Studio exited with code ${code}`);
+      }
+      const s = getGlobalState();
+      if (s.drizzleProcess === proc) {
+        s.drizzleProcess = null;
+      }
+    });
+    console.log(`✅ Drizzle Studio: https://local.drizzle.studio`);
+    return true;
+  } catch (error) {
+    console.error("❌ Failed to start Drizzle Studio:", error);
+    return false;
+  }
+}
+function stopDrizzleStudio(options) {
+  const state = getGlobalState();
+  if (state.drizzleProcess) {
+    state.drizzleProcess.removeAllListeners();
+    state.drizzleProcess.kill();
+    state.drizzleProcess = null;
+    if (options?.log !== false) {
+      console.log("\uD83D\uDED1 Drizzle Studio stopped");
+    }
+    return true;
+  }
+  return false;
+}
+export {
+  getVisionContext,
+  Vision
+};
+
+//# debugId=030980C43D326B6264756E2164756E21