@objectstack/runtime 4.0.1 → 4.0.3

package/.turbo/turbo-build.log

@@ -1,22 +1,22 @@
 
-> @objectstack/runtime@4.0.1 build /home/runner/work/spec/spec/packages/runtime
+> @objectstack/runtime@4.0.3 build /home/runner/work/framework/framework/packages/runtime
 > tsup --config ../../tsup.config.ts
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.1
-CLI Using tsup config: /home/runner/work/spec/spec/tsup.config.ts
+CLI Using tsup config: /home/runner/work/framework/framework/tsup.config.ts
 CLI Target: es2020
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs     90.76 KB
-CJS dist/index.cjs.map 190.74 KB
-CJS ⚡️ Build success in 162ms
-ESM dist/index.js     88.17 KB
-ESM dist/index.js.map 190.67 KB
-ESM ⚡️ Build success in 167ms
+ESM dist/index.js     98.02 KB
+ESM dist/index.js.map 212.66 KB
+ESM ⚡️ Build success in 153ms
+CJS dist/index.cjs     100.63 KB
+CJS dist/index.cjs.map 212.72 KB
+CJS ⚡️ Build success in 153ms
 DTS Build start
-DTS ⚡️ Build success in 5297ms
-DTS dist/index.d.ts  24.35 KB
-DTS dist/index.d.cts 24.35 KB
+DTS ⚡️ Build success in 3771ms
+DTS dist/index.d.ts  26.00 KB
+DTS dist/index.d.cts 26.00 KB

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @objectstack/runtime
 
+## 4.0.3
+
+### Patch Changes
+
+- @objectstack/spec@4.0.3
+- @objectstack/core@4.0.3
+- @objectstack/types@4.0.3
+- @objectstack/rest@4.0.3
+
+## 4.0.2
+
+### Patch Changes
+
+- Updated dependencies [5f659e9]
+  - @objectstack/spec@4.0.2
+  - @objectstack/core@4.0.2
+  - @objectstack/rest@4.0.2
+  - @objectstack/types@4.0.2
+
 ## 4.0.0
 
 ### Patch Changes

package/dist/index.cjs

@@ -646,9 +646,8 @@ var AppPlugin = class {
         pluginName: this.name,
         version: this.version
       });
-      const serviceName = `app.${appId}`;
       const servicePayload = this.bundle.manifest ? { ...this.bundle.manifest, ...this.bundle } : this.bundle;
-      ctx.registerService(serviceName, servicePayload);
+      ctx.getService("manifest").register(servicePayload);
     };
     this.start = async (ctx) => {
       const sys = this.bundle.manifest || this.bundle;
@@ -829,6 +828,7 @@ var AppPlugin = class {
 // src/http-dispatcher.ts
 var import_core2 = require("@objectstack/core");
 var import_system = require("@objectstack/spec/system");
+var import_shared = require("@objectstack/spec/shared");
 function randomUUID() {
   if (globalThis.crypto && typeof globalThis.crypto.randomUUID === "function") {
     return globalThis.crypto.randomUUID();
@@ -856,6 +856,24 @@ var HttpDispatcher = class {
       body: { success: false, error: { message, code, details } }
     };
   }
+  /**
+   * 404 Route Not Found — no route is registered for this path.
+   */
+  routeNotFound(route) {
+    return {
+      status: 404,
+      body: {
+        success: false,
+        error: {
+          code: 404,
+          message: `Route Not Found: ${route}`,
+          type: "ROUTE_NOT_FOUND",
+          route,
+          hint: "No route is registered for this path. Check the API discovery endpoint for available routes."
+        }
+      }
+    };
+  }
   ensureBroker() {
     if (!this.kernel.broker) {
       throw { statusCode: 500, message: "Kernel Broker not available" };
@@ -937,12 +955,14 @@ var HttpDispatcher = class {
     const svcAvailable = (route, provider) => ({
       enabled: true,
       status: "available",
+      handlerReady: true,
       route,
       provider
     });
     const svcUnavailable = (name) => ({
       enabled: false,
       status: "unavailable",
+      handlerReady: false,
       message: `Install a ${name} plugin to enable`
     });
     let locale = { default: "en", supported: ["en"], timezone: "UTC" };
@@ -975,7 +995,7 @@ var HttpDispatcher = class {
       },
       services: {
         // Kernel-provided (always available via protocol implementation)
-        metadata: { enabled: true, status: "degraded", route: routes.metadata, provider: "kernel", message: "In-memory registry; DB persistence pending" },
+        metadata: { enabled: true, status: "degraded", handlerReady: true, route: routes.metadata, provider: "kernel", message: "In-memory registry; DB persistence pending" },
         data: svcAvailable(routes.data, "kernel"),
         // Plugin-provided — only available when a plugin registers the service
         auth: hasAuth ? svcAvailable(routes.auth) : svcUnavailable("auth"),
@@ -1093,18 +1113,66 @@ var HttpDispatcher = class {
     const broker = this.kernel.broker ?? null;
     const parts = path.replace(/^\/+/, "").split("/").filter(Boolean);
     if (parts[0] === "types") {
+      console.log("[HttpDispatcher] Attempting to resolve MetadataService...");
+      console.log("[HttpDispatcher] Available kernel methods:", {
+        hasGetServiceAsync: typeof this.kernel.getServiceAsync === "function",
+        hasGetService: typeof this.kernel.getService === "function",
+        hasContext: !!this.kernel.context,
+        hasContextGetService: typeof this.kernel.context?.getService === "function"
+      });
+      let metadataService = null;
+      if (typeof this.kernel.getServiceAsync === "function") {
+        try {
+          metadataService = await this.kernel.getServiceAsync("metadata");
+          console.log('[HttpDispatcher] kernel.getServiceAsync("metadata") returned:', !!metadataService);
+        } catch (e) {
+          console.log('[HttpDispatcher] kernel.getServiceAsync("metadata") failed:', e.message);
+        }
+      }
+      if (!metadataService && typeof this.kernel.getService === "function") {
+        try {
+          metadataService = await this.kernel.getService("metadata");
+          console.log('[HttpDispatcher] kernel.getService("metadata") returned:', !!metadataService);
+        } catch (e) {
+          console.log('[HttpDispatcher] kernel.getService("metadata") failed:', e.message);
+        }
+      }
+      if (!metadataService && this.kernel.context?.getService) {
+        try {
+          metadataService = await this.kernel.context.getService("metadata");
+          console.log('[HttpDispatcher] kernel.context.getService("metadata") returned:', !!metadataService);
+        } catch (e) {
+          console.log('[HttpDispatcher] kernel.context.getService("metadata") failed:', e.message);
+        }
+      }
+      console.log("[HttpDispatcher] Final metadataService:", !!metadataService, "has getRegisteredTypes:", typeof metadataService?.getRegisteredTypes);
+      if (metadataService && typeof metadataService.getRegisteredTypes === "function") {
+        try {
+          const types = await metadataService.getRegisteredTypes();
+          console.log("[HttpDispatcher] MetadataService.getRegisteredTypes() returned:", types);
+          return { handled: true, response: this.success({ types }) };
+        } catch (e) {
+          console.warn("[HttpDispatcher] MetadataService.getRegisteredTypes() failed:", e.message, e.stack);
+        }
+      } else {
+        console.log("[HttpDispatcher] MetadataService not available or missing getRegisteredTypes, falling back to protocol service");
+      }
       const protocol = await this.resolveService("protocol");
       if (protocol && typeof protocol.getMetaTypes === "function") {
         const result = await protocol.getMetaTypes({});
+        console.log("[HttpDispatcher] Protocol service returned types:", result);
         return { handled: true, response: this.success(result) };
       }
       if (broker) {
         try {
           const data = await broker.call("metadata.types", {}, { request: context.request });
+          console.log("[HttpDispatcher] Broker returned types:", data);
           return { handled: true, response: this.success(data) };
-        } catch {
+        } catch (e) {
+          console.log("[HttpDispatcher] Broker call failed:", e);
         }
       }
+      console.warn("[HttpDispatcher] Falling back to hardcoded defaults for metadata types");
       return { handled: true, response: this.success({ types: ["object", "app", "plugin"] }) };
     }
     if (parts.length === 3 && parts[2] === "published" && (!method || method === "GET")) {
@@ -1127,6 +1195,7 @@ var HttpDispatcher = class {
     }
     if (parts.length === 2) {
       const [type, name] = parts;
+      const packageId = query?.package || void 0;
       if (method === "PUT" && body) {
         const protocol = await this.resolveService("protocol");
         if (protocol && typeof protocol.saveMetaItem === "function") {
@@ -1160,11 +1229,11 @@ var HttpDispatcher = class {
           }
           return { handled: true, response: this.error("Not found", 404) };
         }
-        const singularType = type.endsWith("s") ? type.slice(0, -1) : type;
+        const singularType = (0, import_shared.pluralToSingular)(type);
         const protocol = await this.resolveService("protocol");
         if (protocol && typeof protocol.getMetaItem === "function") {
           try {
-            const data = await protocol.getMetaItem({ type: singularType, name });
+            const data = await protocol.getMetaItem({ type: singularType, name, packageId });
             return { handled: true, response: this.success(data) };
           } catch (e) {
           }
@@ -1192,6 +1261,18 @@ var HttpDispatcher = class {
         } catch {
         }
       }
+      const metadataService = await this.getService(import_system.CoreServiceName.enum.metadata);
+      if (metadataService && typeof metadataService.list === "function") {
+        try {
+          const items = await metadataService.list(typeOrName);
+          if (items && items.length > 0) {
+            return { handled: true, response: this.success({ type: typeOrName, items }) };
+          }
+        } catch (e) {
+          const sanitizedType = String(typeOrName).replace(/[\r\n\t]/g, "");
+          console.debug(`[HttpDispatcher] MetadataService.list() failed for type:`, sanitizedType, "error:", e.message);
+        }
+      }
       if (broker) {
         try {
           if (typeOrName === "objects") {
@@ -1752,19 +1833,108 @@ var HttpDispatcher = class {
   capitalize(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);
   }
+  /**
+   * Handle AI service routes (/ai/chat, /ai/models, /ai/conversations, etc.)
+   * Resolves the AI service and its built-in route handlers, then dispatches.
+   */
+  async handleAI(subPath, method, body, query, _context) {
+    let aiService;
+    try {
+      aiService = await this.resolveService("ai");
+    } catch {
+    }
+    if (!aiService) {
+      return {
+        handled: true,
+        response: {
+          status: 404,
+          body: { success: false, error: { message: "AI service is not configured", code: 404 } }
+        }
+      };
+    }
+    const fullPath = `/api/v1${subPath}`;
+    const matchRoute = (pattern, path) => {
+      const patternParts = pattern.split("/");
+      const pathParts = path.split("/");
+      if (patternParts.length !== pathParts.length) return null;
+      const params = {};
+      for (let i = 0; i < patternParts.length; i++) {
+        if (patternParts[i].startsWith(":")) {
+          params[patternParts[i].substring(1)] = pathParts[i];
+        } else if (patternParts[i] !== pathParts[i]) {
+          return null;
+        }
+      }
+      return params;
+    };
+    const routes = this.kernel.__aiRoutes;
+    if (!routes) {
+      return {
+        handled: true,
+        response: {
+          status: 503,
+          body: { success: false, error: { message: "AI service routes not yet initialized", code: 503 } }
+        }
+      };
+    }
+    for (const route of routes) {
+      if (route.method !== method) continue;
+      const params = matchRoute(route.path, fullPath);
+      if (params === null) continue;
+      const result = await route.handler({ body, params, query });
+      if (result.stream && result.events) {
+        return {
+          handled: true,
+          result: {
+            type: "stream",
+            contentType: result.vercelDataStream ? "text/plain; charset=utf-8" : "text/event-stream",
+            events: result.events,
+            vercelDataStream: result.vercelDataStream,
+            headers: {
+              "Content-Type": result.vercelDataStream ? "text/plain; charset=utf-8" : "text/event-stream",
+              "Cache-Control": "no-cache",
+              "Connection": "keep-alive"
+            }
+          }
+        };
+      }
+      return {
+        handled: true,
+        response: {
+          status: result.status,
+          body: result.body
+        }
+      };
+    }
+    return {
+      handled: true,
+      response: this.routeNotFound(subPath)
+    };
+  }
   /**
    * Main Dispatcher Entry Point
    * Routes the request to the appropriate handler based on path and precedence
    */
-  async dispatch(method, path, body, query, context) {
+  async dispatch(method, path, body, query, context, prefix) {
     const cleanPath = path.replace(/\/$/, "");
     if ((cleanPath === "/discovery" || cleanPath === "") && method === "GET") {
-      const info = await this.getDiscoveryInfo("");
+      const info = await this.getDiscoveryInfo(prefix ?? "");
       return {
         handled: true,
         response: this.success(info)
       };
     }
+    if (cleanPath === "/health" && method === "GET") {
+      return {
+        handled: true,
+        response: this.success({
+          status: "ok",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          version: "1.0.0",
+          uptime: typeof process !== "undefined" ? process.uptime() : void 0
+        })
+      };
+    }
     if (cleanPath.startsWith("/auth")) {
       return this.handleAuth(cleanPath.substring(5), method, body, context);
     }
@@ -1795,6 +1965,9 @@ var HttpDispatcher = class {
     if (cleanPath.startsWith("/i18n")) {
       return this.handleI18n(cleanPath.substring(5), method, query, context);
     }
+    if (cleanPath.startsWith("/ai")) {
+      return this.handleAI(cleanPath, method, body, query, context);
+    }
     if (cleanPath === "/openapi.json" && method === "GET") {
       const broker = this.ensureBroker();
       try {
@@ -1805,7 +1978,10 @@ var HttpDispatcher = class {
     }
     const result = await this.handleApiEndpoint(cleanPath, method, body, query, context);
     if (result.handled) return result;
-    return { handled: false };
+    return {
+      handled: true,
+      response: this.routeNotFound(cleanPath)
+    };
   }
   /**
    * Handles Custom API Endpoints defined in metadata
@@ -1863,6 +2039,64 @@ var HttpDispatcher = class {
 };
 
 // src/dispatcher-plugin.ts
+function mountRouteOnServer(route, server, routePath) {
+  const handler = async (req, res) => {
+    try {
+      const result = await route.handler({
+        body: req.body,
+        params: req.params,
+        query: req.query
+      });
+      if (result.stream && result.events) {
+        res.status(result.status);
+        if (result.headers) {
+          for (const [k, v] of Object.entries(result.headers)) {
+            res.header(k, String(v));
+          }
+        } else {
+          res.header("Content-Type", "text/event-stream");
+          res.header("Cache-Control", "no-cache");
+          res.header("Connection", "keep-alive");
+        }
+        if (typeof res.write === "function" && typeof res.end === "function") {
+          for await (const event of result.events) {
+            res.write(typeof event === "string" ? event : `data: ${JSON.stringify(event)}
+
+`);
+          }
+          res.end();
+        } else {
+          const events = [];
+          for await (const event of result.events) {
+            events.push(event);
+          }
+          res.json({ events });
+        }
+      } else {
+        res.status(result.status);
+        if (result.body !== void 0) {
+          res.json(result.body);
+        } else {
+          res.end();
+        }
+      }
+    } catch (err) {
+      errorResponse(err, res);
+    }
+  };
+  const m = route.method.toLowerCase();
+  if (m === "get" && typeof server.get === "function") {
+    server.get(routePath, handler);
+    return true;
+  } else if (m === "post" && typeof server.post === "function") {
+    server.post(routePath, handler);
+    return true;
+  } else if (m === "delete" && typeof server.delete === "function") {
+    server.delete(routePath, handler);
+    return true;
+  }
+  return false;
+}
 function sendResult(result, res) {
   if (result.handled) {
     if (result.response) {
@@ -1880,7 +2114,15 @@ function sendResult(result, res) {
       return;
     }
   }
-  res.status(404).json({ success: false, error: { message: "Not Found", code: 404 } });
+  res.status(404).json({
+    success: false,
+    error: {
+      message: "Not Found",
+      code: 404,
+      type: "ROUTE_NOT_FOUND",
+      hint: "No handler matched this request. Check the API discovery endpoint for available routes."
+    }
+  });
 }
 function errorResponse(err, res) {
   const code = err.statusCode || 500;
@@ -1912,6 +2154,14 @@ function createDispatcherPlugin(config = {}) {
       server.get(`${prefix}/discovery`, async (_req, res) => {
         res.json({ data: await dispatcher.getDiscoveryInfo(prefix) });
       });
+      server.get(`${prefix}/health`, async (_req, res) => {
+        try {
+          const result = await dispatcher.dispatch("GET", "/health", void 0, {}, { request: _req });
+          sendResult(result, res);
+        } catch (err) {
+          errorResponse(err, res);
+        }
+      });
       server.post(`${prefix}/auth/login`, async (req, res) => {
         try {
           const result = await dispatcher.handleAuth("login", "POST", req.body, { request: req });
@@ -2137,6 +2387,27 @@ function createDispatcherPlugin(config = {}) {
         }
       });
       ctx.logger.info("Dispatcher bridge routes registered", { prefix });
+      ctx.hook("ai:routes", async (routes) => {
+        if (!server) return;
+        for (const route of routes) {
+          const routePath = route.path.startsWith("/api/v1") ? route.path : `${prefix}${route.path}`;
+          mountRouteOnServer(route, server, routePath);
+        }
+        ctx.logger.info(`[Dispatcher] Registered ${routes.length} AI routes`);
+      });
+      const cachedRoutes = kernel.__aiRoutes;
+      if (cachedRoutes && Array.isArray(cachedRoutes) && cachedRoutes.length > 0) {
+        let registered = 0;
+        for (const route of cachedRoutes) {
+          const routePath = route.path.startsWith("/api/v1") ? route.path : `${prefix}${route.path}`;
+          if (mountRouteOnServer(route, server, routePath)) {
+            registered++;
+          }
+        }
+        if (registered > 0) {
+          ctx.logger.info(`[Dispatcher] Recovered ${registered} cached AI routes (hook timing fallback)`);
+        }
+      }
     }
   };
 }