@objectstack/plugin-hono-server 0.4.1 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @objectstack/plugin-hono-server
 
+## 0.6.0
+
+### Minor Changes
+
+- b2df5f7: Unified version bump to 0.5.0
+
+  - Standardized all package versions to 0.5.0 across the monorepo
+  - Fixed driver-memory package.json paths for proper module resolution
+  - Ensured all packages are in sync for the 0.5.0 release
+
+### Patch Changes
+
+- Updated dependencies [b2df5f7]
+  - @objectstack/spec@0.6.0
+  - @objectstack/types@0.6.0
+  - @objectstack/core@0.6.0
+
+## 0.4.2
+
+### Patch Changes
+
+- Unify all package versions to 0.4.2
+- Updated dependencies
+  - @objectstack/spec@0.4.2
+  - @objectstack/runtime@0.4.2
+  - @objectstack/types@0.4.2
+
 ## 0.4.1
 
 ### Patch Changes

package/dist/adapter.d.ts

@@ -0,0 +1,23 @@
+export * from '@objectstack/core';
+import { IHttpServer, RouteHandler, Middleware } from '@objectstack/core';
+import { Hono } from 'hono';
+/**
+ * Hono Implementation of IHttpServer
+ */
+export declare class HonoHttpServer implements IHttpServer {
+    private port;
+    private staticRoot?;
+    private app;
+    private server;
+    constructor(port?: number, staticRoot?: string | undefined);
+    private wrap;
+    get(path: string, handler: RouteHandler): void;
+    post(path: string, handler: RouteHandler): void;
+    put(path: string, handler: RouteHandler): void;
+    delete(path: string, handler: RouteHandler): void;
+    patch(path: string, handler: RouteHandler): void;
+    use(pathOrHandler: string | Middleware, handler?: Middleware): void;
+    listen(port: number): Promise<void>;
+    getRawApp(): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+    close(): Promise<void>;
+}

package/dist/adapter.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HonoHttpServer = void 0;
+// Export IHttpServer from core
+__exportStar(require("@objectstack/core"), exports);
+const hono_1 = require("hono");
+const node_server_1 = require("@hono/node-server");
+const serve_static_1 = require("@hono/node-server/serve-static");
+/**
+ * Hono Implementation of IHttpServer
+ */
+class HonoHttpServer {
+    port;
+    staticRoot;
+    app;
+    server;
+    constructor(port = 3000, staticRoot) {
+        this.port = port;
+        this.staticRoot = staticRoot;
+        this.app = new hono_1.Hono();
+    }
+    // internal helper to convert standard handler to Hono handler
+    wrap(handler) {
+        return async (c) => {
+            const req = {
+                params: c.req.param(),
+                query: c.req.query(),
+                body: await c.req.parseBody().catch(() => { }), // fallback
+                headers: c.req.header(),
+                method: c.req.method,
+                path: c.req.path
+            };
+            // Try to parse JSON body if possible
+            if (c.req.header('content-type')?.includes('application/json')) {
+                try {
+                    req.body = await c.req.json();
+                }
+                catch (e) { }
+            }
+            let capturedResponse;
+            const res = {
+                json: (data) => { capturedResponse = c.json(data); },
+                send: (data) => { capturedResponse = c.html(data); },
+                status: (code) => { c.status(code); return res; },
+                header: (name, value) => { c.header(name, value); return res; }
+            };
+            await handler(req, res);
+            return capturedResponse;
+        };
+    }
+    get(path, handler) {
+        this.app.get(path, this.wrap(handler));
+    }
+    post(path, handler) {
+        this.app.post(path, this.wrap(handler));
+    }
+    put(path, handler) {
+        this.app.put(path, this.wrap(handler));
+    }
+    delete(path, handler) {
+        this.app.delete(path, this.wrap(handler));
+    }
+    patch(path, handler) {
+        this.app.patch(path, this.wrap(handler));
+    }
+    use(pathOrHandler, handler) {
+        if (typeof pathOrHandler === 'string' && handler) {
+            // Path based middleware
+            // Hono middleware signature is different (c, next) => ...
+            this.app.use(pathOrHandler, async (c, next) => {
+                // Simplistic conversion
+                await handler({}, {}, next);
+            });
+        }
+        else if (typeof pathOrHandler === 'function') {
+            // Global middleware
+            this.app.use('*', async (c, next) => {
+                await pathOrHandler({}, {}, next);
+            });
+        }
+    }
+    async listen(port) {
+        return new Promise((resolve) => {
+            if (this.staticRoot) {
+                this.app.get('/*', (0, serve_static_1.serveStatic)({ root: this.staticRoot }));
+            }
+            this.server = (0, node_server_1.serve)({
+                fetch: this.app.fetch,
+                port: port || this.port
+            }, (info) => {
+                resolve();
+            });
+        });
+    }
+    // Expose raw app for scenarios where standard interface is not enough
+    getRawApp() {
+        return this.app;
+    }
+    async close() {
+        if (this.server && typeof this.server.close === 'function') {
+            this.server.close();
+        }
+    }
+}
+exports.HonoHttpServer = HonoHttpServer;

package/dist/hono-plugin.d.ts

@@ -1,13 +1,30 @@
-import { RuntimePlugin, RuntimeContext } from '@objectstack/runtime';
+import { Plugin, PluginContext } from '@objectstack/core';
 export interface HonoPluginOptions {
     port?: number;
     staticRoot?: string;
 }
-export declare class HonoServerPlugin implements RuntimePlugin {
+/**
+ * Hono Server Plugin
+ *
+ * Provides HTTP server capabilities using Hono framework.
+ * Registers routes for ObjectStack Runtime Protocol.
+ */
+export declare class HonoServerPlugin implements Plugin {
     name: string;
+    version: string;
     private options;
-    private app;
+    private server;
     constructor(options?: HonoPluginOptions);
-    install(ctx: RuntimeContext): void;
-    onStart(ctx: RuntimeContext): Promise<void>;
+    /**
+     * Init phase - Setup HTTP server and register as service
+     */
+    init(ctx: PluginContext): Promise<void>;
+    /**
+     * Start phase - Bind routes and start listening
+     */
+    start(ctx: PluginContext): Promise<void>;
+    /**
+     * Destroy phase - Stop server
+     */
+    destroy(): Promise<void>;
 }

package/dist/hono-plugin.js

@@ -1,117 +1,128 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HonoServerPlugin = void 0;
-const node_server_1 = require("@hono/node-server");
-const serve_static_1 = require("@hono/node-server/serve-static");
-const hono_1 = require("hono");
-const cors_1 = require("hono/cors");
-const logger_1 = require("hono/logger");
-const runtime_1 = require("@objectstack/runtime");
+const adapter_1 = require("./adapter");
+/**
+ * Hono Server Plugin
+ *
+ * Provides HTTP server capabilities using Hono framework.
+ * Registers routes for ObjectStack Runtime Protocol.
+ */
 class HonoServerPlugin {
-    name = 'hono-server';
+    name = 'com.objectstack.server.hono';
+    version = '1.0.0';
     options;
-    app;
+    server;
     constructor(options = {}) {
         this.options = {
             port: 3000,
             ...options
         };
-        this.app = new hono_1.Hono();
+        this.server = new adapter_1.HonoHttpServer(this.options.port, this.options.staticRoot);
     }
-    install(ctx) {
-        const { engine } = ctx;
-        const protocol = new runtime_1.ObjectStackRuntimeProtocol(engine);
-        // Middleware
-        this.app.use('*', (0, logger_1.logger)());
-        this.app.use('*', (0, cors_1.cors)());
-        // --- Bind Protocol to Hono ---
-        // 1. Discovery
-        this.app.get('/api/v1', (c) => c.json(protocol.getDiscovery()));
-        // 2. Meta
-        this.app.get('/api/v1/meta', (c) => c.json(protocol.getMetaTypes()));
-        this.app.get('/api/v1/meta/:type', (c) => c.json(protocol.getMetaItems(c.req.param('type'))));
-        this.app.get('/api/v1/meta/:type/:name', (c) => {
-            try {
-                return c.json(protocol.getMetaItem(c.req.param('type'), c.req.param('name')));
-            }
-            catch (e) {
-                return c.json({ error: e.message }, 404);
-            }
-        });
-        // 3. Data
-        this.app.get('/api/v1/data/:object', async (c) => {
-            try {
-                const result = await protocol.findData(c.req.param('object'), c.req.query());
-                return c.json(result);
-            }
-            catch (e) {
-                return c.json({ error: e.message }, 404);
-            }
-        });
-        this.app.get('/api/v1/data/:object/:id', async (c) => {
-            try {
-                const result = await protocol.getData(c.req.param('object'), c.req.param('id'));
-                return c.json(result);
-            }
-            catch (e) {
-                return c.json({ error: e.message }, 404);
-            }
-        });
-        this.app.post('/api/v1/data/:object', async (c) => {
-            try {
-                const body = await c.req.json();
-                const result = await protocol.createData(c.req.param('object'), body);
-                return c.json(result, 201);
-            }
-            catch (e) {
-                return c.json({ error: e.message }, 400);
-            }
-        });
-        this.app.patch('/api/v1/data/:object/:id', async (c) => {
-            try {
-                const body = await c.req.json();
-                const result = await protocol.updateData(c.req.param('object'), c.req.param('id'), body);
-                return c.json(result);
-            }
-            catch (e) {
-                return c.json({ error: e.message }, 400);
-            }
-        });
-        this.app.delete('/api/v1/data/:object/:id', async (c) => {
-            try {
-                const result = await protocol.deleteData(c.req.param('object'), c.req.param('id'));
-                return c.json(result);
-            }
-            catch (e) {
-                return c.json({ error: e.message }, 400);
-            }
-        });
-        // 4. UI Protocol
-        this.app.get('/api/v1/ui/view/:object', (c) => {
-            try {
-                // @ts-ignore
-                const view = protocol.getUiView(c.req.param('object'), c.req.query('type') || 'list');
-                return c.json(view);
-            }
-            catch (e) {
-                return c.json({ error: e.message }, 404);
-            }
-        });
-        // Static Files
-        if (this.options.staticRoot) {
-            this.app.get('/', (0, serve_static_1.serveStatic)({ root: this.options.staticRoot, path: 'index.html' }));
-            this.app.get('/*', (0, serve_static_1.serveStatic)({ root: this.options.staticRoot }));
-        }
-        console.log(`[HonoPlugin] Installed routes and middleware.`);
+    /**
+     * Init phase - Setup HTTP server and register as service
+     */
+    async init(ctx) {
+        // Register HTTP server service as IHttpServer
+        ctx.registerService('http-server', this.server);
+        ctx.logger.log('[HonoServerPlugin] HTTP server service registered');
     }
-    async onStart(ctx) {
-        const port = this.options.port;
-        console.log(`[HonoPlugin] Starting server...`);
-        console.log(`✅ Server is running on http://localhost:${port}`);
-        (0, node_server_1.serve)({
-            fetch: this.app.fetch,
-            port
+    /**
+     * Start phase - Bind routes and start listening
+     */
+    async start(ctx) {
+        // Get protocol implementation instance
+        let protocol = null;
+        try {
+            protocol = ctx.getService('protocol');
+        }
+        catch (e) {
+            ctx.logger.log('[HonoServerPlugin] Protocol service not found, skipping protocol routes');
+        }
+        // Register protocol routes if available
+        if (protocol) {
+            const p = protocol;
+            this.server.get('/api/v1', (req, res) => res.json(p.getDiscovery()));
+            // Meta Protocol
+            this.server.get('/api/v1/meta', (req, res) => res.json(p.getMetaTypes()));
+            this.server.get('/api/v1/meta/:type', (req, res) => res.json(p.getMetaItems(req.params.type)));
+            this.server.get('/api/v1/meta/:type/:name', (req, res) => {
+                try {
+                    res.json(p.getMetaItem(req.params.type, req.params.name));
+                }
+                catch (e) {
+                    res.status(404).json({ error: e.message });
+                }
+            });
+            // Data Protocol
+            this.server.get('/api/v1/data/:object', async (req, res) => {
+                try {
+                    res.json(await p.findData(req.params.object, req.query));
+                }
+                catch (e) {
+                    res.status(400).json({ error: e.message });
+                }
+            });
+            this.server.get('/api/v1/data/:object/:id', async (req, res) => {
+                try {
+                    res.json(await p.getData(req.params.object, req.params.id));
+                }
+                catch (e) {
+                    res.status(404).json({ error: e.message });
+                }
+            });
+            this.server.post('/api/v1/data/:object', async (req, res) => {
+                try {
+                    res.status(201).json(await p.createData(req.params.object, req.body));
+                }
+                catch (e) {
+                    res.status(400).json({ error: e.message });
+                }
+            });
+            this.server.patch('/api/v1/data/:object/:id', async (req, res) => {
+                try {
+                    res.json(await p.updateData(req.params.object, req.params.id, req.body));
+                }
+                catch (e) {
+                    res.status(400).json({ error: e.message });
+                }
+            });
+            this.server.delete('/api/v1/data/:object/:id', async (req, res) => {
+                try {
+                    res.json(await p.deleteData(req.params.object, req.params.id));
+                }
+                catch (e) {
+                    res.status(400).json({ error: e.message });
+                }
+            });
+            // UI Protocol
+            // @ts-ignore
+            this.server.get('/api/v1/ui/view/:object', (req, res) => {
+                try {
+                    const viewType = (req.query.type) || 'list';
+                    const qt = Array.isArray(viewType) ? viewType[0] : viewType;
+                    res.json(p.getUiView(req.params.object, qt));
+                }
+                catch (e) {
+                    res.status(404).json({ error: e.message });
+                }
+            });
+        }
+        // Start server on kernel:ready hook
+        ctx.hook('kernel:ready', async () => {
+            const port = this.options.port || 3000;
+            ctx.logger.log('[HonoServerPlugin] Starting server...');
+            await this.server.listen(port);
+            ctx.logger.log(`✅ Server is running on http://localhost:${port}`);
         });
     }
+    /**
+     * Destroy phase - Stop server
+     */
+    async destroy() {
+        this.server.close();
+        console.log('[HonoServerPlugin] Server stopped');
+    }
 }
 exports.HonoServerPlugin = HonoServerPlugin;

package/dist/index.d.ts

@@ -1,21 +1,2 @@
-import { RuntimePlugin, IKernel } from '@objectstack/types';
-export interface HonoServerOptions {
-    port?: number;
-    staticRoot?: string;
-    cors?: boolean;
-    logger?: boolean;
-}
-/**
- * Hono Server Runtime Plugin
- *
- * Exposes the ObjectStack Kernel via standard HTTP Protocol using Hono.
- * Can be used for Production (Standalone) or Development.
- */
-export declare class HonoServerPlugin implements RuntimePlugin {
-    name: string;
-    private options;
-    constructor(options?: HonoServerOptions);
-    onStart(ctx: {
-        engine: IKernel;
-    }): Promise<void>;
-}
+export * from './hono-plugin';
+export * from './adapter';

package/dist/index.js

@@ -1,113 +1,18 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HonoServerPlugin = void 0;
-const node_server_1 = require("@hono/node-server");
-const serve_static_1 = require("@hono/node-server/serve-static");
-const hono_1 = require("hono");
-const cors_1 = require("hono/cors");
-const logger_1 = require("hono/logger");
-const runtime_1 = require("@objectstack/runtime");
-/**
- * Hono Server Runtime Plugin
- *
- * Exposes the ObjectStack Kernel via standard HTTP Protocol using Hono.
- * Can be used for Production (Standalone) or Development.
- */
-class HonoServerPlugin {
-    name = 'com.objectstack.server.hono';
-    options;
-    constructor(options = {}) {
-        this.options = {
-            port: 3000,
-            cors: true,
-            logger: true,
-            ...options
-        };
-    }
-    async onStart(ctx) {
-        const app = new hono_1.Hono();
-        // TODO: Protocol needs access to actual Kernel instance or we make Protocol an interface too
-        const protocol = new runtime_1.ObjectStackRuntimeProtocol(ctx.engine);
-        // 1. Middlewares
-        if (this.options.logger)
-            app.use('*', (0, logger_1.logger)());
-        if (this.options.cors)
-            app.use('*', (0, cors_1.cors)());
-        // 2. Wiring Protocol (Automatic)
-        // Discovery
-        app.get('/api/v1', (c) => c.json(protocol.getDiscovery()));
-        // Meta Protocol
-        app.get('/api/v1/meta', (c) => c.json(protocol.getMetaTypes()));
-        app.get('/api/v1/meta/:type', (c) => c.json(protocol.getMetaItems(c.req.param('type'))));
-        app.get('/api/v1/meta/:type/:name', (c) => {
-            try {
-                return c.json(protocol.getMetaItem(c.req.param('type'), c.req.param('name')));
-            }
-            catch (e) {
-                return c.json({ error: e.message }, 404);
-            }
-        });
-        // Data Protocol
-        app.get('/api/v1/data/:object', async (c) => {
-            try {
-                return c.json(await protocol.findData(c.req.param('object'), c.req.query()));
-            }
-            catch (e) {
-                return c.json({ error: e.message }, 400);
-            }
-        });
-        app.get('/api/v1/data/:object/:id', async (c) => {
-            try {
-                return c.json(await protocol.getData(c.req.param('object'), c.req.param('id')));
-            }
-            catch (e) {
-                return c.json({ error: e.message }, 404);
-            }
-        });
-        app.post('/api/v1/data/:object', async (c) => {
-            try {
-                return c.json(await protocol.createData(c.req.param('object'), await c.req.json()), 201);
-            }
-            catch (e) {
-                return c.json({ error: e.message }, 400);
-            }
-        });
-        app.patch('/api/v1/data/:object/:id', async (c) => {
-            try {
-                return c.json(await protocol.updateData(c.req.param('object'), c.req.param('id'), await c.req.json()));
-            }
-            catch (e) {
-                return c.json({ error: e.message }, 400);
-            }
-        });
-        app.delete('/api/v1/data/:object/:id', async (c) => {
-            try {
-                return c.json(await protocol.deleteData(c.req.param('object'), c.req.param('id')));
-            }
-            catch (e) {
-                return c.json({ error: e.message }, 400);
-            }
-        });
-        // UI Protocol
-        // @ts-ignore
-        app.get('/api/v1/ui/view/:object', (c) => {
-            try {
-                const viewType = c.req.query('type') || 'list';
-                return c.json(protocol.getUiView(c.req.param('object'), viewType));
-            }
-            catch (e) {
-                return c.json({ error: e.message }, 404);
-            }
-        });
-        // 3. Static Files (Optional)
-        if (this.options.staticRoot) {
-            app.get('/', (0, serve_static_1.serveStatic)({ root: this.options.staticRoot, path: 'index.html' }));
-            app.get('/*', (0, serve_static_1.serveStatic)({ root: this.options.staticRoot }));
-        }
-        console.log('');
-        console.log(`🌍 ObjectStack Server (Hono) running at: http://localhost:${this.options.port}`);
-        console.log('');
-        (0, node_server_1.serve)({ fetch: app.fetch, port: this.options.port });
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-}
-exports.HonoServerPlugin = HonoServerPlugin;
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hono-plugin"), exports);
+__exportStar(require("./adapter"), exports);

package/package.json

@@ -1,22 +1,19 @@
 {
   "name": "@objectstack/plugin-hono-server",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "Standard Hono Server Adapter for ObjectStack Runtime",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
     "@hono/node-server": "^1.2.0",
     "hono": "^4.0.0",
-    "@objectstack/spec": "0.4.1",
-    "@objectstack/types": "0.4.1"
+    "@objectstack/core": "0.6.0",
+    "@objectstack/spec": "0.6.0",
+    "@objectstack/types": "0.6.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "typescript": "^5.0.0",
-    "@objectstack/runtime": "0.4.1"
-  },
-  "peerDependencies": {
-    "@objectstack/runtime": "^0.4.1"
+    "typescript": "^5.0.0"
   },
   "scripts": {
     "build": "tsc"

package/src/adapter.ts

@@ -0,0 +1,117 @@
+// Export IHttpServer from core
+export * from '@objectstack/core';
+
+import { 
+    IHttpServer, 
+    RouteHandler, 
+    Middleware 
+} from '@objectstack/core';
+import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+import { serveStatic } from '@hono/node-server/serve-static';
+
+/**
+ * Hono Implementation of IHttpServer
+ */
+export class HonoHttpServer implements IHttpServer {
+    private app: Hono;
+    private server: any;
+
+    constructor(
+        private port: number = 3000,
+        private staticRoot?: string
+    ) {
+        this.app = new Hono();
+    }
+
+    // internal helper to convert standard handler to Hono handler
+    private wrap(handler: RouteHandler) {
+        return async (c: any) => {
+            const req = {
+                params: c.req.param(),
+                query: c.req.query(),
+                body: await c.req.parseBody().catch(() => {}), // fallback
+                headers: c.req.header(),
+                method: c.req.method,
+                path: c.req.path
+            };
+            
+            // Try to parse JSON body if possible
+            if (c.req.header('content-type')?.includes('application/json')) {
+                try { req.body = await c.req.json(); } catch(e) {}
+            }
+
+            let capturedResponse: any;
+
+            const res = {
+                json: (data: any) => { capturedResponse = c.json(data); },
+                send: (data: string) => { capturedResponse = c.html(data); },
+                status: (code: number) => { c.status(code); return res; },
+                header: (name: string, value: string) => { c.header(name, value); return res; }
+            };
+
+            await handler(req as any, res as any);
+            return capturedResponse;
+        };
+    }
+
+    get(path: string, handler: RouteHandler) {
+        this.app.get(path, this.wrap(handler));
+    }
+    post(path: string, handler: RouteHandler) {
+        this.app.post(path, this.wrap(handler));
+    }
+    put(path: string, handler: RouteHandler) {
+        this.app.put(path, this.wrap(handler));
+    }
+    delete(path: string, handler: RouteHandler) {
+        this.app.delete(path, this.wrap(handler));
+    }
+    patch(path: string, handler: RouteHandler) {
+        this.app.patch(path, this.wrap(handler));
+    }
+    
+    use(pathOrHandler: string | Middleware, handler?: Middleware) {
+        if (typeof pathOrHandler === 'string' && handler) {
+             // Path based middleware
+             // Hono middleware signature is different (c, next) => ...
+             this.app.use(pathOrHandler, async (c, next) => {
+                 // Simplistic conversion
+                 await handler({} as any, {} as any, next);
+             });
+        } else if (typeof pathOrHandler === 'function') {
+             // Global middleware
+             this.app.use('*', async (c, next) => {
+                 await pathOrHandler({} as any, {} as any, next);
+             });
+        }
+    }
+
+    async listen(port: number) {
+        return new Promise<void>((resolve) => {
+            if (this.staticRoot) {
+                this.app.get('/*', serveStatic({ root: this.staticRoot }));
+            }
+            
+            this.server = serve({
+                fetch: this.app.fetch,
+                port: port || this.port
+            }, (info) => {
+                resolve();
+            });
+        });
+    }
+
+    // Expose raw app for scenarios where standard interface is not enough
+    getRawApp() {
+        return this.app;
+    }
+
+    async close() {
+        if (this.server && typeof this.server.close === 'function') {
+            this.server.close();
+        }
+    }
+
+
+}

package/src/hono-plugin.ts

@@ -1,128 +1,120 @@
-import { serve } from '@hono/node-server';
-import { serveStatic } from '@hono/node-server/serve-static';
-import { Hono } from 'hono';
-import { cors } from 'hono/cors';
-import { logger } from 'hono/logger';
-import { RuntimePlugin, RuntimeContext, ObjectStackRuntimeProtocol } from '@objectstack/runtime';
+import { Plugin, PluginContext, IHttpServer } from '@objectstack/core';
+import { IObjectStackProtocol } from '@objectstack/spec/api';
+import { HonoHttpServer } from './adapter';
 
 export interface HonoPluginOptions {
     port?: number;
     staticRoot?: string;
 }
 
-export class HonoServerPlugin implements RuntimePlugin {
-    name = 'hono-server';
+/**
+ * Hono Server Plugin
+ * 
+ * Provides HTTP server capabilities using Hono framework.
+ * Registers routes for ObjectStack Runtime Protocol.
+ */
+export class HonoServerPlugin implements Plugin {
+    name = 'com.objectstack.server.hono';
+    version = '1.0.0';
+    
     private options: HonoPluginOptions;
-    private app: Hono;
+    private server: HonoHttpServer;
 
     constructor(options: HonoPluginOptions = {}) {
         this.options = { 
             port: 3000,
             ...options
         };
-        this.app = new Hono();
+        this.server = new HonoHttpServer(this.options.port, this.options.staticRoot);
     }
 
-    install(ctx: RuntimeContext) {
-        const { engine } = ctx;
-        const protocol = new ObjectStackRuntimeProtocol(engine);
-
-        // Middleware
-        this.app.use('*', logger());
-        this.app.use('*', cors());
+    /**
+     * Init phase - Setup HTTP server and register as service
+     */
+    async init(ctx: PluginContext) {
+        // Register HTTP server service as IHttpServer
+        ctx.registerService('http-server', this.server);
+        ctx.logger.log('[HonoServerPlugin] HTTP server service registered');
+    }
 
-        // --- Bind Protocol to Hono ---
+    /**
+     * Start phase - Bind routes and start listening
+     */
+    async start(ctx: PluginContext) {
+        // Get protocol implementation instance
+        let protocol: IObjectStackProtocol | null = null;
         
-        // 1. Discovery
-        this.app.get('/api/v1', (c) => c.json(protocol.getDiscovery()));
-
-        // 2. Meta
-        this.app.get('/api/v1/meta', (c) => c.json(protocol.getMetaTypes()));
-        this.app.get('/api/v1/meta/:type', (c) => c.json(protocol.getMetaItems(c.req.param('type'))));
-        this.app.get('/api/v1/meta/:type/:name', (c) => {
-             try {
-                 return c.json(protocol.getMetaItem(c.req.param('type'), c.req.param('name')));
-             } catch (e: any) {
-                 return c.json({ error: e.message }, 404);
-             }
-        });
-
-        // 3. Data
-        this.app.get('/api/v1/data/:object', async (c) => {
-            try {
-                const result = await protocol.findData(c.req.param('object'), c.req.query());
-                return c.json(result);
-            } catch (e: any) {
-                return c.json({ error: e.message }, 404);
-            }
-        });
-
-        this.app.get('/api/v1/data/:object/:id', async (c) => {
-            try {
-                const result = await protocol.getData(c.req.param('object'), c.req.param('id'));
-                return c.json(result);
-            } catch (e: any) {
-                return c.json({ error: e.message }, 404);
-            }
-        });
-
-        this.app.post('/api/v1/data/:object', async (c) => {
-            try {
-                const body = await c.req.json();
-                const result = await protocol.createData(c.req.param('object'), body);
-                return c.json(result, 201);
-            } catch (e: any) {
-                return c.json({ error: e.message }, 400);
-            }
-        });
+        try {
+            protocol = ctx.getService<IObjectStackProtocol>('protocol');
+        } catch (e) {
+            ctx.logger.log('[HonoServerPlugin] Protocol service not found, skipping protocol routes');
+        }
 
-        this.app.patch('/api/v1/data/:object/:id', async (c) => {
-            try {
-                const body = await c.req.json();
-                const result = await protocol.updateData(c.req.param('object'), c.req.param('id'), body);
-                return c.json(result);
-            } catch (e: any) {
-                return c.json({ error: e.message }, 400);
-            }
-        });
+        // Register protocol routes if available
+        if (protocol) {
+            const p = protocol!;
+            this.server.get('/api/v1', (req, res) => res.json(p.getDiscovery()));
 
-        this.app.delete('/api/v1/data/:object/:id', async (c) => {
-            try {
-                const result = await protocol.deleteData(c.req.param('object'), c.req.param('id'));
-                return c.json(result);
-            } catch (e: any) {
-                return c.json({ error: e.message }, 400);
-            }
-        });
-        
-        // 4. UI Protocol
-        this.app.get('/api/v1/ui/view/:object', (c) => {
-            try {
-                // @ts-ignore
-                const view = protocol.getUiView(c.req.param('object'), c.req.query('type') || 'list');
-                return c.json(view);
-            } catch (e: any) {
-                return c.json({ error: e.message }, 404);
-            }
-        });
+            // Meta Protocol
+            this.server.get('/api/v1/meta', (req, res) => res.json(p.getMetaTypes()));
+            this.server.get('/api/v1/meta/:type', (req, res) => res.json(p.getMetaItems(req.params.type)));
+            this.server.get('/api/v1/meta/:type/:name', (req, res) => {
+                try {
+                    res.json(p.getMetaItem(req.params.type, req.params.name));
+                } catch(e:any) {
+                    res.status(404).json({error: e.message});
+                }
+            });
+            
+            // Data Protocol
+            this.server.get('/api/v1/data/:object', async (req, res) => {
+                try { res.json(await p.findData(req.params.object, req.query)); } 
+                catch(e:any) { res.status(400).json({error:e.message}); }
+            });
+            this.server.get('/api/v1/data/:object/:id', async (req, res) => {
+                try { res.json(await p.getData(req.params.object, req.params.id)); }
+                catch(e:any) { res.status(404).json({error:e.message}); }
+            });
+            this.server.post('/api/v1/data/:object', async (req, res) => {
+                try { res.status(201).json(await p.createData(req.params.object, req.body)); }
+                catch(e:any) { res.status(400).json({error:e.message}); }
+            });
+            this.server.patch('/api/v1/data/:object/:id', async (req, res) => {
+                try { res.json(await p.updateData(req.params.object, req.params.id, req.body)); }
+                catch(e:any) { res.status(400).json({error:e.message}); }
+            });
+            this.server.delete('/api/v1/data/:object/:id', async (req, res) => {
+                try { res.json(await p.deleteData(req.params.object, req.params.id)); }
+                catch(e:any) { res.status(400).json({error:e.message}); }
+            });
 
-        // Static Files
-        if (this.options.staticRoot) {
-            this.app.get('/', serveStatic({ root: this.options.staticRoot, path: 'index.html' }));
-            this.app.get('/*', serveStatic({ root: this.options.staticRoot }));
+            // UI Protocol
+            // @ts-ignore
+            this.server.get('/api/v1/ui/view/:object', (req, res) => {
+                try { 
+                    const viewType = (req.query.type) || 'list';
+                    const qt = Array.isArray(viewType) ? viewType[0] : viewType;
+                    res.json(p.getUiView(req.params.object, qt as any)); 
+                }
+                catch(e:any) { res.status(404).json({error:e.message}); }
+            });
         }
 
-        console.log(`[HonoPlugin] Installed routes and middleware.`);
+        // Start server on kernel:ready hook
+        ctx.hook('kernel:ready', async () => {
+            const port = this.options.port || 3000;
+            ctx.logger.log('[HonoServerPlugin] Starting server...');
+            
+            await this.server.listen(port);
+            ctx.logger.log(`✅ Server is running on http://localhost:${port}`);
+        });
     }
 
-    async onStart(ctx: RuntimeContext) {
-        const port = this.options.port;
-        console.log(`[HonoPlugin] Starting server...`);
-        console.log(`✅ Server is running on http://localhost:${port}`);
-        
-        serve({
-            fetch: this.app.fetch,
-            port
-        });
+    /**
+     * Destroy phase - Stop server
+     */
+    async destroy() {
+        this.server.close();
+        console.log('[HonoServerPlugin] Server stopped');
     }
 }

package/src/index.ts

@@ -1,104 +1,3 @@
-import { serve } from '@hono/node-server';
-import { serveStatic } from '@hono/node-server/serve-static';
-import { Hono } from 'hono';
-import { cors } from 'hono/cors';
-import { logger } from 'hono/logger';
-import { ObjectStackRuntimeProtocol } from '@objectstack/runtime';
-import { RuntimePlugin, IKernel } from '@objectstack/types';
+export * from './hono-plugin';
+export * from './adapter';
 
-export interface HonoServerOptions {
-  port?: number;
-  staticRoot?: string;
-  cors?: boolean;
-  logger?: boolean;
-}
-
-/**
- * Hono Server Runtime Plugin
- * 
- * Exposes the ObjectStack Kernel via standard HTTP Protocol using Hono.
- * Can be used for Production (Standalone) or Development.
- */
-export class HonoServerPlugin implements RuntimePlugin {
-  name = 'com.objectstack.server.hono';
-  
-  private options: HonoServerOptions;
-
-  constructor(options: HonoServerOptions = {}) {
-    this.options = { 
-        port: 3000, 
-        cors: true,
-        logger: true,
-        ...options 
-    };
-  }
-
-  async onStart(ctx: { engine: IKernel }) {
-    const app = new Hono();
-    // TODO: Protocol needs access to actual Kernel instance or we make Protocol an interface too
-    const protocol = new ObjectStackRuntimeProtocol(ctx.engine as any);
-
-    // 1. Middlewares
-    if (this.options.logger) app.use('*', logger());
-    if (this.options.cors) app.use('*', cors());
-
-    // 2. Wiring Protocol (Automatic)
-    // Discovery
-    app.get('/api/v1', (c) => c.json(protocol.getDiscovery()));
-    
-    // Meta Protocol
-    app.get('/api/v1/meta', (c) => c.json(protocol.getMetaTypes()));
-    app.get('/api/v1/meta/:type', (c) => c.json(protocol.getMetaItems(c.req.param('type'))));
-    app.get('/api/v1/meta/:type/:name', (c) => {
-        try {
-            return c.json(protocol.getMetaItem(c.req.param('type'), c.req.param('name')));
-        } catch(e:any) {
-            return c.json({error: e.message}, 404);
-        }
-    });
-    
-    // Data Protocol
-    app.get('/api/v1/data/:object', async (c) => {
-        try { return c.json(await protocol.findData(c.req.param('object'), c.req.query())); } 
-        catch(e:any) { return c.json({error:e.message}, 400); }
-    });
-    app.get('/api/v1/data/:object/:id', async (c) => {
-        try { return c.json(await protocol.getData(c.req.param('object'), c.req.param('id'))); }
-        catch(e:any) { return c.json({error:e.message}, 404); }
-    });
-    app.post('/api/v1/data/:object', async (c) => {
-        try { return c.json(await protocol.createData(c.req.param('object'), await c.req.json()), 201); }
-        catch(e:any) { return c.json({error:e.message}, 400); }
-    });
-    app.patch('/api/v1/data/:object/:id', async (c) => {
-        try { return c.json(await protocol.updateData(c.req.param('object'), c.req.param('id'), await c.req.json())); }
-        catch(e:any) { return c.json({error:e.message}, 400); }
-    });
-    app.delete('/api/v1/data/:object/:id', async (c) => {
-        try { return c.json(await protocol.deleteData(c.req.param('object'), c.req.param('id'))); }
-        catch(e:any) { return c.json({error:e.message}, 400); }
-    });
-
-    // UI Protocol
-    // @ts-ignore
-    app.get('/api/v1/ui/view/:object', (c) => {
-        try { 
-            const viewType = (c.req.query('type') as 'list' | 'form') || 'list';
-            return c.json(protocol.getUiView(c.req.param('object'), viewType)); 
-        }
-        catch(e:any) { return c.json({error:e.message}, 404); }
-    });
-
-    // 3. Static Files (Optional)
-    if (this.options.staticRoot) {
-        app.get('/', serveStatic({ root: this.options.staticRoot, path: 'index.html' }));
-        app.get('/*', serveStatic({ root: this.options.staticRoot }));
-    }
-
-    console.log('');
-    console.log(`🌍 ObjectStack Server (Hono) running at: http://localhost:${this.options.port}`);
-    console.log('');
-    
-    serve({ fetch: app.fetch, port: this.options.port });
-  }
-}