@objectstack/runtime 1.0.11 → 1.0.12

package/package.json

@@ -1,16 +1,23 @@
 {
   "name": "@objectstack/runtime",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "license": "Apache-2.0",
   "description": "ObjectStack Core Runtime & Query Engine",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
   "dependencies": {
     "zod": "^3.24.1",
-    "@objectstack/core": "1.0.11",
-    "@objectstack/spec": "1.0.11",
-    "@objectstack/types": "1.0.11"
+    "@objectstack/core": "1.0.12",
+    "@objectstack/spec": "1.0.12",
+    "@objectstack/types": "1.0.12"
   },
   "devDependencies": {
     "typescript": "^5.0.0",

package/src/app-plugin.ts

@@ -99,22 +99,45 @@ export class AppPlugin implements Plugin {
         }
 
         // Data Seeding
-        // Check for 'data' in manifest (Legacy or Stack Definition)
+        // Collect seed data from multiple locations (top-level `data` preferred, `manifest.data` for backward compat)
+        const seedDatasets: any[] = [];
+        
+        // 1. Top-level `data` field (new standard location on ObjectStackDefinition)
+        if (Array.isArray(this.bundle.data)) {
+            seedDatasets.push(...this.bundle.data);
+        }
+        
+        // 2. Legacy: `manifest.data` (backward compatibility)
         const manifest = this.bundle.manifest || this.bundle;
         if (manifest && Array.isArray(manifest.data)) {
-             ctx.logger.info(`[AppPlugin] Found initial data for ${appId}`, { count: manifest.data.length });
-             for (const dataset of manifest.data) {
+            seedDatasets.push(...manifest.data);
+        }
+
+        // Resolve short object names to FQN using the package's namespace.
+        // e.g., seed `object: 'task'` in namespace 'todo' → 'todo__task'
+        // Reserved namespaces ('base', 'system') are not prefixed.
+        const namespace = (this.bundle.manifest || this.bundle)?.namespace as string | undefined;
+        const RESERVED_NS = new Set(['base', 'system']);
+        const toFQN = (name: string) => {
+            if (name.includes('__') || !namespace || RESERVED_NS.has(namespace)) return name;
+            return `${namespace}__${name}`;
+        };
+        
+        if (seedDatasets.length > 0) {
+             ctx.logger.info(`[AppPlugin] Found ${seedDatasets.length} seed datasets for ${appId}`);
+             for (const dataset of seedDatasets) {
                  if (dataset.object && Array.isArray(dataset.records)) {
-                     ctx.logger.info(`[Seeder] Seeding ${dataset.records.length} records for ${dataset.object}`);
+                     const objectFQN = toFQN(dataset.object);
+                     ctx.logger.info(`[Seeder] Seeding ${dataset.records.length} records for ${objectFQN}`);
                      for (const record of dataset.records) {
                           try {
                               // Use ObjectQL engine to insert data
                               // This ensures driver resolution and hook execution
                               // Use 'insert' which corresponds to 'create' in driver
-                              await ql.insert(dataset.object, record);
+                              await ql.insert(objectFQN, record);
                           } catch (err: any) {
                               // Ignore duplicate errors if needed, or log/warn
-                              ctx.logger.warn(`[Seeder] Failed to insert ${dataset.object} record:`, { error: err.message });
+                              ctx.logger.warn(`[Seeder] Failed to insert ${objectFQN} record:`, { error: err.message });
                           }
                      }
                  }

package/src/http-dispatcher.root.test.ts

@@ -0,0 +1,58 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HttpDispatcher } from './http-dispatcher';
+import { ObjectKernel } from '@objectstack/core';
+
+describe('HttpDispatcher Root Handling', () => {
+    let kernel: ObjectKernel;
+    let dispatcher: HttpDispatcher;
+
+    beforeEach(() => {
+        // Mock minimal Kernel structure
+        kernel = {
+            services: {},
+            broker: {
+                call: vi.fn(),
+            },
+            context: {
+                getService: vi.fn(),
+            }
+        } as any;
+
+        dispatcher = new HttpDispatcher(kernel);
+    });
+
+    it('should handled GET request to root path ("") correctly', async () => {
+        const context = { request: {} };
+        const method = 'GET';
+        // MSW passes empty string when stripping base URL
+        const path = ''; 
+        const body = undefined;
+        const query = {};
+
+        const result = await dispatcher.dispatch(method, path, body, query, context);
+
+        expect(result.handled).toBe(true);
+        expect(result.response).toBeDefined();
+        expect(result.response?.status).toBe(200);
+        
+        const data = result.response?.body?.data;
+        expect(data).toBeDefined();
+        // getDiscoveryInfo returns 'name' not 'apiName'
+        expect(data.name).toBe('ObjectOS');
+        expect(data.version).toBe('1.0.0');
+        expect(data.routes).toBeDefined();
+        // Since we passed empty prefix in dispatch code (hardcoded), routes should be relative
+        expect(data.routes.metadata).toBe('/meta');
+    });
+
+    it('should NOT handle POST request to root path ("")', async () => {
+        const context = { request: {} };
+        const method = 'POST';
+        const path = '';
+        
+        const result = await dispatcher.dispatch(method, path, {}, {}, context);
+
+        expect(result.handled).toBe(false);
+    });
+});

package/src/http-dispatcher.ts

@@ -57,19 +57,25 @@ export class HttpDispatcher {
         const hasAnalytics = !!services[CoreServiceName.enum.analytics];
         const hasHub = !!services[CoreServiceName.enum.hub];
 
-        return {
-            name: 'ObjectOS',
-            version: '1.0.0',
-            environment: getEnv('NODE_ENV', 'development'),
-            routes: {
+        const routes = {
                 data: `${prefix}/data`,
                 metadata: `${prefix}/meta`,
+                packages: `${prefix}/packages`,
                 auth: `${prefix}/auth`,
+                ui: `${prefix}/ui`,
                 graphql: hasGraphQL ? `${prefix}/graphql` : undefined,
                 storage: hasFiles ? `${prefix}/storage` : undefined,
                 analytics: hasAnalytics ? `${prefix}/analytics` : undefined,
                 hub: hasHub ? `${prefix}/hub` : undefined,
-            },
+                automation: `${prefix}/automation`, 
+        };
+
+        return {
+            name: 'ObjectOS',
+            version: '1.0.0',
+            environment: getEnv('NODE_ENV', 'development'),
+            routes,
+            endpoints: routes, // Alias for backward compatibility with some clients
             features: {
                 graphql: hasGraphQL,
                 search: hasSearch,
@@ -131,15 +137,26 @@ export class HttpDispatcher {
      * Standard: /metadata/:type/:name
      * Fallback for backward compat: /metadata (all objects), /metadata/:objectName (get object)
      */
-    async handleMetadata(path: string, context: HttpProtocolContext, method?: string, body?: any): Promise<HttpDispatcherResult> {
+    async handleMetadata(path: string, context: HttpProtocolContext, method?: string, body?: any, query?: any): Promise<HttpDispatcherResult> {
         const broker = this.ensureBroker();
         const parts = path.replace(/^\/+/, '').split('/').filter(Boolean);
         
         // GET /metadata/types
         if (parts[0] === 'types') {
-            // This would normally come from a registry service
-            // For now we mock the types supported by core
-            return { handled: true, response: this.success({ types: ['objects', 'apps', 'plugins'] }) };
+            // Try protocol service for dynamic types
+            const protocol = this.kernel?.context?.getService ? this.kernel.context.getService('protocol') : null;
+            if (protocol && typeof protocol.getMetaTypes === 'function') {
+                const result = await protocol.getMetaTypes({});
+                return { handled: true, response: this.success(result) };
+            }
+            // Fallback: ask broker for registered types
+            try {
+                const data = await broker.call('metadata.types', {}, { request: context.request });
+                return { handled: true, response: this.success(data) };
+            } catch {
+                // Last resort: hardcoded defaults
+                return { handled: true, response: this.success({ types: ['object', 'app', 'plugin'] }) };
+            }
         }
 
         // /metadata/:type/:name
@@ -172,12 +189,30 @@ export class HttpDispatcher {
 
             try {
                 // Try specific calls based on type
-                if (type === 'objects') {
+                if (type === 'objects' || type === 'object') {
                     const data = await broker.call('metadata.getObject', { objectName: name }, { request: context.request });
                     return { handled: true, response: this.success(data) };
                 }
-                // Generic call for other types if supported
-                const data = await broker.call(`metadata.get${this.capitalize(type.slice(0, -1))}`, { name }, { request: context.request });
+
+                // If type is singular (e.g. 'app'), use it directly
+                // If plural (e.g. 'apps'), slice it
+                const singularType = type.endsWith('s') ? type.slice(0, -1) : type;
+                
+                // Try Protocol Service First (Preferred)
+                const protocol = this.kernel?.context?.getService ? this.kernel.context.getService('protocol') : null;
+                if (protocol && typeof protocol.getMetaItem === 'function') {
+                     try {
+                        const data = await protocol.getMetaItem({ type: singularType, name });
+                        return { handled: true, response: this.success(data) };
+                     } catch (e: any) {
+                        // Protocol might throw if not found or not supported
+                        // Fallback to broker?
+                     }
+                }
+
+                // Generic call for other types if supported via Broker (Legacy)
+                const method = `metadata.get${this.capitalize(singularType)}`;
+                const data = await broker.call(method, { name }, { request: context.request });
                 return { handled: true, response: this.success(data) };
             } catch (e: any) {
                 // Fallback: treat first part as object name if only 1 part (handled below)
@@ -189,27 +224,61 @@ export class HttpDispatcher {
         // GET /metadata/:type (List items of type) OR /metadata/:objectName (Legacy)
         if (parts.length === 1) {
             const typeOrName = parts[0];
+            // Extract optional package filter from query string
+            const packageId = query?.package || undefined;
             
-            // Heuristic: if it maps to a known type, list it. Else treat as object name.
-            if (['objects', 'apps', 'plugins'].includes(typeOrName)) {
-                 if (typeOrName === 'objects') {
-                     const data = await broker.call('metadata.objects', {}, { request: context.request });
-                     return { handled: true, response: this.success(data) };
-                 }
-                 // Try generic list
-                 const data = await broker.call(`metadata.${typeOrName}`, {}, { request: context.request });
-                 return { handled: true, response: this.success(data) };
+            // Try protocol service first for any type
+            const protocol = this.kernel?.context?.getService ? this.kernel.context.getService('protocol') : null;
+            if (protocol && typeof protocol.getMetaItems === 'function') {
+                try {
+                    const data = await protocol.getMetaItems({ type: typeOrName, packageId });
+                    // Return any valid response from protocol (including empty items arrays)
+                    if (data && (data.items !== undefined || Array.isArray(data))) {
+                        return { handled: true, response: this.success(data) };
+                    }
+                } catch {
+                    // Protocol doesn't know this type, fall through
+                }
             }
 
-            // Legacy: /metadata/:objectName
-            const data = await broker.call('metadata.getObject', { objectName: typeOrName }, { request: context.request });
-            return { handled: true, response: this.success(data) };
+            // Try broker for the type
+            try {
+                if (typeOrName === 'objects') {
+                    const data = await broker.call('metadata.objects', { packageId }, { request: context.request });
+                    return { handled: true, response: this.success(data) };
+                }
+                const data = await broker.call(`metadata.${typeOrName}`, { packageId }, { request: context.request });
+                if (data !== null && data !== undefined) {
+                    return { handled: true, response: this.success(data) };
+                }
+            } catch {
+                // Broker doesn't support this action, fall through
+            }
+
+            // Legacy: /metadata/:objectName (treat as single object lookup)
+            try {
+                const data = await broker.call('metadata.getObject', { objectName: typeOrName }, { request: context.request });
+                return { handled: true, response: this.success(data) };
+            } catch (e: any) {
+                return { handled: true, response: this.error(e.message, 404) };
+            }
         }
 
-        // GET /metadata (List Objects - Default)
+        // GET /metadata — return available metadata types
         if (parts.length === 0) {
-            const data = await broker.call('metadata.objects', {}, { request: context.request });
-            return { handled: true, response: this.success(data) };
+            // Try protocol service for dynamic types
+            const protocol = this.kernel?.context?.getService ? this.kernel.context.getService('protocol') : null;
+            if (protocol && typeof protocol.getMetaTypes === 'function') {
+                const result = await protocol.getMetaTypes({});
+                return { handled: true, response: this.success(result) };
+            }
+            // Fallback: ask broker for registered types
+            try {
+                const data = await broker.call('metadata.types', {}, { request: context.request });
+                return { handled: true, response: this.success(data) };
+            } catch {
+                return { handled: true, response: this.success({ types: ['object', 'app', 'plugin'] }) };
+            }
         }
         
         return { handled: false };
@@ -236,14 +305,13 @@ export class HttpDispatcher {
             
             // POST /data/:object/query
             if (action === 'query' && m === 'POST') {
+                // Spec: broker returns FindDataResponse = { object, records, total?, hasMore? }
                 const result = await broker.call('data.query', { object: objectName, ...body }, { request: context.request });
-                return { handled: true, response: this.success(result.data, { count: result.count, limit: body.limit, skip: body.skip }) };
+                return { handled: true, response: this.success(result) };
             }
 
             // POST /data/:object/batch
             if (action === 'batch' && m === 'POST') {
-                // Spec complaint: forward the whole body { operation, records, options }
-                // Implementation in Kernel should handle the 'operation' field
                 const result = await broker.call('data.batch', { object: objectName, ...body }, { request: context.request });
                 return { handled: true, response: this.success(result) };
             }
@@ -251,35 +319,39 @@ export class HttpDispatcher {
             // GET /data/:object/:id
             if (parts.length === 2 && m === 'GET') {
                 const id = parts[1];
-                const data = await broker.call('data.get', { object: objectName, id, ...query }, { request: context.request });
-                return { handled: true, response: this.success(data) };
+                // Spec: broker returns GetDataResponse = { object, id, record }
+                const result = await broker.call('data.get', { object: objectName, id, ...query }, { request: context.request });
+                return { handled: true, response: this.success(result) };
             }
 
             // PATCH /data/:object/:id
             if (parts.length === 2 && m === 'PATCH') {
                 const id = parts[1];
-                const data = await broker.call('data.update', { object: objectName, id, data: body }, { request: context.request });
-                return { handled: true, response: this.success(data) };
+                // Spec: broker returns UpdateDataResponse = { object, id, record }
+                const result = await broker.call('data.update', { object: objectName, id, data: body }, { request: context.request });
+                return { handled: true, response: this.success(result) };
             }
 
             // DELETE /data/:object/:id
             if (parts.length === 2 && m === 'DELETE') {
                 const id = parts[1];
-                await broker.call('data.delete', { object: objectName, id }, { request: context.request });
-                return { handled: true, response: this.success({ id, deleted: true }) };
+                // Spec: broker returns DeleteDataResponse = { object, id, deleted }
+                const result = await broker.call('data.delete', { object: objectName, id }, { request: context.request });
+                return { handled: true, response: this.success(result) };
             }
         } else {
             // GET /data/:object (List)
             if (m === 'GET') {
+                // Spec: broker returns FindDataResponse = { object, records, total?, hasMore? }
                 const result = await broker.call('data.query', { object: objectName, filters: query }, { request: context.request });
-                return { handled: true, response: this.success(result.data, { count: result.count }) };
+                return { handled: true, response: this.success(result) };
             }
 
             // POST /data/:object (Create)
             if (m === 'POST') {
-                const data = await broker.call('data.create', { object: objectName, data: body }, { request: context.request });
-                // Note: ideally 201
-                const res = this.success(data);
+                // Spec: broker returns CreateDataResponse = { object, id, record }
+                const result = await broker.call('data.create', { object: objectName, data: body }, { request: context.request });
+                const res = this.success(result);
                 res.status = 201;
                 return { handled: true, response: res };
             }
@@ -321,6 +393,138 @@ export class HttpDispatcher {
         return { handled: false };
     }
 
+    /**
+     * Handles Package Management requests
+     * 
+     * REST Endpoints:
+     * - GET    /packages          → list all installed packages
+     * - GET    /packages/:id      → get a specific package
+     * - POST   /packages          → install a new package
+     * - DELETE  /packages/:id      → uninstall a package
+     * - PATCH  /packages/:id/enable  → enable a package
+     * - PATCH  /packages/:id/disable → disable a package
+     * 
+     * Uses ObjectQL SchemaRegistry directly (via the 'objectql' service)
+     * with broker fallback for backward compatibility.
+     */
+    async handlePackages(path: string, method: string, body: any, query: any, context: HttpProtocolContext): Promise<HttpDispatcherResult> {
+        const m = method.toUpperCase();
+        const parts = path.replace(/^\/+/, '').split('/').filter(Boolean);
+
+        // Try to get SchemaRegistry from the ObjectQL service
+        const qlService = this.getObjectQLService();
+        const registry = qlService?.registry;
+
+        // If no registry available, try broker as fallback
+        if (!registry) {
+            if (this.kernel.broker) {
+                return this.handlePackagesViaBroker(parts, m, body, query, context);
+            }
+            return { handled: true, response: this.error('Package service not available', 503) };
+        }
+
+        try {
+            // GET /packages → list packages
+            if (parts.length === 0 && m === 'GET') {
+                let packages = registry.getAllPackages();
+                // Apply optional filters
+                if (query?.status) {
+                    packages = packages.filter((p: any) => p.status === query.status);
+                }
+                if (query?.type) {
+                    packages = packages.filter((p: any) => p.manifest?.type === query.type);
+                }
+                return { handled: true, response: this.success({ packages, total: packages.length }) };
+            }
+
+            // POST /packages → install package
+            if (parts.length === 0 && m === 'POST') {
+                const pkg = registry.installPackage(body.manifest || body, body.settings);
+                const res = this.success(pkg);
+                res.status = 201;
+                return { handled: true, response: res };
+            }
+
+            // PATCH /packages/:id/enable
+            if (parts.length === 2 && parts[1] === 'enable' && m === 'PATCH') {
+                const id = decodeURIComponent(parts[0]);
+                const pkg = registry.enablePackage(id);
+                if (!pkg) return { handled: true, response: this.error(`Package '${id}' not found`, 404) };
+                return { handled: true, response: this.success(pkg) };
+            }
+
+            // PATCH /packages/:id/disable
+            if (parts.length === 2 && parts[1] === 'disable' && m === 'PATCH') {
+                const id = decodeURIComponent(parts[0]);
+                const pkg = registry.disablePackage(id);
+                if (!pkg) return { handled: true, response: this.error(`Package '${id}' not found`, 404) };
+                return { handled: true, response: this.success(pkg) };
+            }
+
+            // GET /packages/:id → get package
+            if (parts.length === 1 && m === 'GET') {
+                const id = decodeURIComponent(parts[0]);
+                const pkg = registry.getPackage(id);
+                if (!pkg) return { handled: true, response: this.error(`Package '${id}' not found`, 404) };
+                return { handled: true, response: this.success(pkg) };
+            }
+
+            // DELETE /packages/:id → uninstall package
+            if (parts.length === 1 && m === 'DELETE') {
+                const id = decodeURIComponent(parts[0]);
+                const success = registry.uninstallPackage(id);
+                if (!success) return { handled: true, response: this.error(`Package '${id}' not found`, 404) };
+                return { handled: true, response: this.success({ success: true }) };
+            }
+        } catch (e: any) {
+            return { handled: true, response: this.error(e.message, e.statusCode || 500) };
+        }
+
+        return { handled: false };
+    }
+
+    /**
+     * Fallback: handle packages via broker (for backward compatibility)
+     */
+    private async handlePackagesViaBroker(parts: string[], m: string, body: any, query: any, context: HttpProtocolContext): Promise<HttpDispatcherResult> {
+        const broker = this.kernel.broker;
+        try {
+            if (parts.length === 0 && m === 'GET') {
+                const result = await broker.call('package.list', query || {}, { request: context.request });
+                return { handled: true, response: this.success(result) };
+            }
+            if (parts.length === 0 && m === 'POST') {
+                const result = await broker.call('package.install', body, { request: context.request });
+                const res = this.success(result);
+                res.status = 201;
+                return { handled: true, response: res };
+            }
+            if (parts.length === 2 && parts[1] === 'enable' && m === 'PATCH') {
+                const id = decodeURIComponent(parts[0]);
+                const result = await broker.call('package.enable', { id }, { request: context.request });
+                return { handled: true, response: this.success(result) };
+            }
+            if (parts.length === 2 && parts[1] === 'disable' && m === 'PATCH') {
+                const id = decodeURIComponent(parts[0]);
+                const result = await broker.call('package.disable', { id }, { request: context.request });
+                return { handled: true, response: this.success(result) };
+            }
+            if (parts.length === 1 && m === 'GET') {
+                const id = decodeURIComponent(parts[0]);
+                const result = await broker.call('package.get', { id }, { request: context.request });
+                return { handled: true, response: this.success(result) };
+            }
+            if (parts.length === 1 && m === 'DELETE') {
+                const id = decodeURIComponent(parts[0]);
+                const result = await broker.call('package.uninstall', { id }, { request: context.request });
+                return { handled: true, response: this.success(result) };
+            }
+        } catch (e: any) {
+            return { handled: true, response: this.error(e.message, e.statusCode || 500) };
+        }
+        return { handled: false };
+    }
+
     /**
      * Handles Hub requests
      * path: sub-path after /hub/
@@ -450,6 +654,36 @@ export class HttpDispatcher {
         return { handled: false };
     }
 
+    /**
+     * Handles UI requests
+     * path: sub-path after /ui/
+     */
+    async handleUi(path: string, query: any, _context: HttpProtocolContext): Promise<HttpDispatcherResult> {
+        const parts = path.replace(/^\/+/, '').split('/').filter(Boolean);
+        
+        // GET /ui/view/:object (with optional type param)
+        if (parts[0] === 'view' && parts[1]) {
+            const objectName = parts[1];
+            // Support both path param /view/obj/list AND query param /view/obj?type=list
+            const type = parts[2] || query?.type || 'list';
+
+            const protocol = this.kernel?.context?.getService ? this.kernel.context.getService('protocol') : null;
+            
+            if (protocol && typeof protocol.getUiView === 'function') {
+                try {
+                    const result = await protocol.getUiView({ object: objectName, type });
+                    return { handled: true, response: this.success(result) };
+                } catch (e: any) {
+                    return { handled: true, response: this.error(e.message, 500) };
+                }
+            } else {
+                 return { handled: true, response: this.error('Protocol service not available', 503) };
+            }
+        }
+
+        return { handled: false };
+    }
+
     /**
      * Handles Automation requests
      * path: sub-path after /automation/
@@ -488,6 +722,31 @@ export class HttpDispatcher {
         return services[name];
     }
 
+    /**
+     * Get the ObjectQL service which provides access to SchemaRegistry.
+     * Tries multiple access patterns since kernel structure varies.
+     */
+    private getObjectQLService(): any {
+        // 1. Try via kernel.getService
+        if (typeof this.kernel.getService === 'function') {
+            try {
+                const svc = this.kernel.getService('objectql');
+                if (svc?.registry) return svc;
+            } catch { /* ignore */ }
+        }
+        // 2. Try via kernel context
+        if (this.kernel?.context?.getService) {
+            try {
+                const svc = this.kernel.context.getService('objectql');
+                if (svc?.registry) return svc;
+            } catch { /* ignore */ }
+        }
+        // 3. Try via services map
+        const services = this.getServicesMap();
+        if (services['objectql']?.registry) return services['objectql'];
+        return null;
+    }
+
     private capitalize(s: string) {
         return s.charAt(0).toUpperCase() + s.slice(1);
     }
@@ -499,13 +758,24 @@ export class HttpDispatcher {
     async dispatch(method: string, path: string, body: any, query: any, context: HttpProtocolContext): Promise<HttpDispatcherResult> {
         const cleanPath = path.replace(/\/$/, ''); // Remove trailing slash if present, but strict on clean paths
 
+        // 0. Root Discovery Endpoint (GET /)
+        // Handles request to base URL (e.g. /api/v1) which MSW strips to empty string
+        if (cleanPath === '' && method === 'GET') {
+             // We use '' as prefix since we are internal dispatcher
+             const info = this.getDiscoveryInfo('');
+             return { 
+                 handled: true, 
+                 response: this.success(info) 
+             };
+        }
+
         // 1. System Protocols (Prefix-based)
         if (cleanPath.startsWith('/auth')) {
             return this.handleAuth(cleanPath.substring(5), method, body, context);
         }
         
         if (cleanPath.startsWith('/meta')) {
-             return this.handleMetadata(cleanPath.substring(5), context);
+             return this.handleMetadata(cleanPath.substring(5), context, method, body, query);
         }
 
         if (cleanPath.startsWith('/data')) {
@@ -521,6 +791,10 @@ export class HttpDispatcher {
              return this.handleStorage(cleanPath.substring(8), method, body, context); // body here is file/stream for upload
         }
         
+        if (cleanPath.startsWith('/ui')) {
+             return this.handleUi(cleanPath.substring(3), query, context);
+        }
+
         if (cleanPath.startsWith('/automation')) {
              return this.handleAutomation(cleanPath.substring(11), method, body, context);
         }
@@ -533,6 +807,10 @@ export class HttpDispatcher {
              return this.handleHub(cleanPath.substring(4), method, body, query, context);
         }
 
+        if (cleanPath.startsWith('/packages')) {
+             return this.handlePackages(cleanPath.substring(9), method, body, query, context);
+        }
+
         // OpenAPI Specification
         if (cleanPath === '/openapi.json' && method === 'GET') {
              const broker = this.ensureBroker();