feat(runtime): add publish/revert/getPublished HTTP endpoints to HttpDispatcher and dispatcher-plugin

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

packages/runtime/src/dispatcher-plugin.ts

@@ -199,6 +199,24 @@ export function createDispatcherPlugin(config: DispatcherPluginConfig = {}): Plu
                 }
             });
 
+            server.post(`${prefix}/packages/:id/publish`, async (req: any, res: any) => {
+                try {
+                    const result = await dispatcher.handlePackages(`/${req.params.id}/publish`, 'POST', req.body, {}, { request: req });
+                    sendResult(result, res);
+                } catch (err: any) {
+                    errorResponse(err, res);
+                }
+            });
+
+            server.post(`${prefix}/packages/:id/revert`, async (req: any, res: any) => {
+                try {
+                    const result = await dispatcher.handlePackages(`/${req.params.id}/revert`, 'POST', req.body, {}, { request: req });
+                    sendResult(result, res);
+                } catch (err: any) {
+                    errorResponse(err, res);
+                }
+            });
+
             // ── Storage ─────────────────────────────────────────────────
             server.post(`${prefix}/storage/upload`, async (req: any, res: any) => {
                 try {

packages/runtime/src/http-dispatcher.test.ts

@@ -469,4 +469,124 @@ describe('HttpDispatcher', () => {
             ).rejects.toThrow('Disk full');
         });
     });
+
+    // ═══════════════════════════════════════════════════════════════
+    // Package Publish / Revert Endpoints
+    // ═══════════════════════════════════════════════════════════════
+
+    describe('Package publish/revert endpoints', () => {
+        it('should handle POST /packages/:id/publish via metadata service', async () => {
+            const mockMetadata = {
+                publishPackage: vi.fn().mockResolvedValue({
+                    success: true,
+                    packageId: 'com.acme.crm',
+                    version: 2,
+                    publishedAt: '2025-06-01T00:00:00Z',
+                    itemsPublished: 3,
+                }),
+            };
+            const mockRegistry = {
+                getAllPackages: vi.fn().mockReturnValue([]),
+                enablePackage: vi.fn(),
+                disablePackage: vi.fn(),
+            };
+            (kernel as any).getService = vi.fn().mockImplementation((name: string) => {
+                if (name === 'metadata') return Promise.resolve(mockMetadata);
+                if (name === 'objectql') return Promise.resolve({ registry: mockRegistry });
+                return null;
+            });
+
+            const result = await dispatcher.handlePackages('/com.acme.crm/publish', 'POST', { publishedBy: 'admin' }, {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(mockMetadata.publishPackage).toHaveBeenCalledWith('com.acme.crm', { publishedBy: 'admin' });
+        });
+
+        it('should handle POST /packages/:id/revert via metadata service', async () => {
+            const mockMetadata = {
+                revertPackage: vi.fn().mockResolvedValue(undefined),
+            };
+            const mockRegistry = {
+                getAllPackages: vi.fn().mockReturnValue([]),
+                enablePackage: vi.fn(),
+                disablePackage: vi.fn(),
+            };
+            (kernel as any).getService = vi.fn().mockImplementation((name: string) => {
+                if (name === 'metadata') return Promise.resolve(mockMetadata);
+                if (name === 'objectql') return Promise.resolve({ registry: mockRegistry });
+                return null;
+            });
+
+            const result = await dispatcher.handlePackages('/com.acme.crm/revert', 'POST', {}, {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(mockMetadata.revertPackage).toHaveBeenCalledWith('com.acme.crm');
+        });
+
+        it('should fallback to broker for publish when metadata service unavailable', async () => {
+            const mockRegistry = {
+                getAllPackages: vi.fn().mockReturnValue([]),
+            };
+            (kernel as any).getService = vi.fn().mockImplementation((name: string) => {
+                if (name === 'metadata') return Promise.resolve(null);
+                if (name === 'objectql') return Promise.resolve({ registry: mockRegistry });
+                return null;
+            });
+            mockBroker.call.mockResolvedValue({ success: true, packageId: 'crm', version: 1, publishedAt: '2025-01-01T00:00:00Z', itemsPublished: 2 });
+
+            const result = await dispatcher.handlePackages('/crm/publish', 'POST', {}, {}, { request: {} });
+            expect(result.handled).toBe(true);
+            expect(mockBroker.call).toHaveBeenCalledWith('metadata.publishPackage', { packageId: 'crm' }, { request: {} });
+        });
+    });
+
+    // ═══════════════════════════════════════════════════════════════
+    // Metadata getPublished Endpoint
+    // ═══════════════════════════════════════════════════════════════
+
+    describe('Metadata getPublished endpoint', () => {
+        it('should handle GET /metadata/:type/:name/published via metadata service', async () => {
+            const mockMetadata = {
+                getPublished: vi.fn().mockResolvedValue({ name: 'account', label: 'Account' }),
+            };
+            (kernel as any).getService = vi.fn().mockImplementation((name: string) => {
+                if (name === 'metadata') return Promise.resolve(mockMetadata);
+                return null;
+            });
+
+            const result = await dispatcher.handleMetadata('/object/account/published', { request: {} }, 'GET');
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(result.response?.body?.data).toEqual({ name: 'account', label: 'Account' });
+            expect(mockMetadata.getPublished).toHaveBeenCalledWith('object', 'account');
+        });
+
+        it('should return 404 when published item not found', async () => {
+            const mockMetadata = {
+                getPublished: vi.fn().mockResolvedValue(undefined),
+            };
+            (kernel as any).getService = vi.fn().mockImplementation((name: string) => {
+                if (name === 'metadata') return Promise.resolve(mockMetadata);
+                return null;
+            });
+
+            const result = await dispatcher.handleMetadata('/object/nonexistent/published', { request: {} }, 'GET');
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(404);
+        });
+
+        it('should fallback to broker for getPublished when metadata service unavailable', async () => {
+            (kernel as any).getService = vi.fn().mockResolvedValue(null);
+            mockBroker.call.mockResolvedValue({ name: 'account', fields: ['name'] });
+
+            const result = await dispatcher.handleMetadata('/object/account/published', { request: {} }, 'GET');
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(mockBroker.call).toHaveBeenCalledWith(
+                'metadata.getPublished',
+                { type: 'object', name: 'account' },
+                { request: {} }
+            );
+        });
+    });
 });

packages/runtime/src/http-dispatcher.ts

@@ -217,6 +217,24 @@ export class HttpDispatcher {
             }
         }
 
+        // GET /metadata/:type/:name/published → get published version
+        if (parts.length === 3 && parts[2] === 'published' && (!method || method === 'GET')) {
+            const [type, name] = parts;
+            const metadataService = await this.getService(CoreServiceName.enum.metadata);
+            if (metadataService && typeof (metadataService as any).getPublished === 'function') {
+                const data = await (metadataService as any).getPublished(type, name);
+                if (data === undefined) return { handled: true, response: this.error('Not found', 404) };
+                return { handled: true, response: this.success(data) };
+            }
+            // Broker fallback
+            try {
+                const data = await broker.call('metadata.getPublished', { type, name }, { request: context.request });
+                return { handled: true, response: this.success(data) };
+            } catch (e: any) {
+                return { handled: true, response: this.error(e.message, 404) };
+            }
+        }
+
         // /metadata/:type/:name
         if (parts.length === 2) {
             const [type, name] = parts;
@@ -467,6 +485,8 @@ export class HttpDispatcher {
      * - DELETE  /packages/:id      → uninstall a package
      * - PATCH  /packages/:id/enable  → enable a package
      * - PATCH  /packages/:id/disable → disable a package
+     * - POST   /packages/:id/publish → publish a package (metadata snapshot)
+     * - POST   /packages/:id/revert  → revert a package to last published state
      * 
      * Uses ObjectQL SchemaRegistry directly (via the 'objectql' service)
      * with broker fallback for backward compatibility.
@@ -525,6 +545,38 @@ export class HttpDispatcher {
                 return { handled: true, response: this.success(pkg) };
             }
 
+            // POST /packages/:id/publish → publish package metadata
+            if (parts.length === 2 && parts[1] === 'publish' && m === 'POST') {
+                const id = decodeURIComponent(parts[0]);
+                const metadataService = await this.getService(CoreServiceName.enum.metadata);
+                if (metadataService && typeof (metadataService as any).publishPackage === 'function') {
+                    const result = await (metadataService as any).publishPackage(id, body || {});
+                    return { handled: true, response: this.success(result) };
+                }
+                // Broker fallback
+                if (this.kernel.broker) {
+                    const result = await this.kernel.broker.call('metadata.publishPackage', { packageId: id, ...body }, { request: context.request });
+                    return { handled: true, response: this.success(result) };
+                }
+                return { handled: true, response: this.error('Metadata service not available', 503) };
+            }
+
+            // POST /packages/:id/revert → revert package to last published state
+            if (parts.length === 2 && parts[1] === 'revert' && m === 'POST') {
+                const id = decodeURIComponent(parts[0]);
+                const metadataService = await this.getService(CoreServiceName.enum.metadata);
+                if (metadataService && typeof (metadataService as any).revertPackage === 'function') {
+                    await (metadataService as any).revertPackage(id);
+                    return { handled: true, response: this.success({ success: true }) };
+                }
+                // Broker fallback
+                if (this.kernel.broker) {
+                    await this.kernel.broker.call('metadata.revertPackage', { packageId: id }, { request: context.request });
+                    return { handled: true, response: this.success({ success: true }) };
+                }
+                return { handled: true, response: this.error('Metadata service not available', 503) };
+            }
+
             // GET /packages/:id → get package
             if (parts.length === 1 && m === 'GET') {
                 const id = decodeURIComponent(parts[0]);