@objectstack/plugin-hono-server 1.0.2 → 1.0.5

package/dist/index.mjs

@@ -0,0 +1,256 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  HonoHttpServer: () => HonoHttpServer,
+  HonoServerPlugin: () => HonoServerPlugin
+});
+
+// src/adapter.ts
+var adapter_exports = {};
+__export(adapter_exports, {
+  HonoHttpServer: () => HonoHttpServer
+});
+__reExport(adapter_exports, core_star);
+import * as core_star from "@objectstack/core";
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+var HonoHttpServer = class {
+  constructor(port = 3e3, staticRoot) {
+    this.port = port;
+    this.staticRoot = staticRoot;
+    __publicField(this, "app");
+    __publicField(this, "server");
+    __publicField(this, "listeningPort");
+    this.app = new Hono();
+  }
+  // internal helper to convert standard handler to Hono handler
+  wrap(handler) {
+    return async (c) => {
+      let body = {};
+      if (c.req.header("content-type")?.includes("application/json")) {
+        try {
+          body = await c.req.json();
+        } catch (e) {
+          try {
+            body = await c.req.parseBody();
+          } catch (e2) {
+          }
+        }
+      } else {
+        try {
+          body = await c.req.parseBody();
+        } catch (e) {
+        }
+      }
+      const req = {
+        params: c.req.param(),
+        query: c.req.query(),
+        body,
+        headers: c.req.header(),
+        method: c.req.method,
+        path: c.req.path
+      };
+      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) {
+      this.app.use(pathOrHandler, async (c, next) => {
+        await handler({}, {}, next);
+      });
+    } else if (typeof pathOrHandler === "function") {
+      this.app.use("*", async (c, next) => {
+        await pathOrHandler({}, {}, next);
+      });
+    }
+  }
+  /**
+   * Mount a sub-application or router
+   */
+  mount(path, subApp) {
+    this.app.route(path, subApp);
+  }
+  async listen(port) {
+    return new Promise((resolve) => {
+      if (this.staticRoot) {
+        this.app.get("/*", serveStatic({ root: this.staticRoot }));
+      }
+      const targetPort = port || this.port;
+      this.server = serve({
+        fetch: this.app.fetch,
+        port: targetPort
+      }, (info) => {
+        this.listeningPort = info.port;
+        resolve();
+      });
+    });
+  }
+  getPort() {
+    return this.listeningPort || this.port;
+  }
+  // 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();
+    }
+  }
+};
+
+// src/hono-plugin.ts
+import { createHonoApp } from "@objectstack/hono";
+import { serveStatic as serveStatic2 } from "@hono/node-server/serve-static";
+var HonoServerPlugin = class {
+  constructor(options = {}) {
+    __publicField(this, "name", "com.objectstack.server.hono");
+    __publicField(this, "version", "0.9.0");
+    __publicField(this, "options");
+    __publicField(this, "server");
+    /**
+     * Init phase - Setup HTTP server and register as service
+     */
+    __publicField(this, "init", async (ctx) => {
+      ctx.logger.debug("Initializing Hono server plugin", {
+        port: this.options.port,
+        staticRoot: this.options.staticRoot
+      });
+      ctx.registerService("http.server", this.server);
+      ctx.registerService("http-server", this.server);
+      ctx.logger.debug("HTTP server service registered", { serviceName: "http.server" });
+    });
+    /**
+     * Start phase - Bind routes and start listening
+     */
+    __publicField(this, "start", async (ctx) => {
+      ctx.logger.debug("Starting Hono server plugin");
+      try {
+        const kernel = ctx.getKernel();
+        const config = this.options.restConfig || {};
+        const apiVersion = config.api?.version || "v1";
+        const basePath = config.api?.basePath || "/api";
+        const apiPath = config.api?.apiPath || `${basePath}/${apiVersion}`;
+        const app = createHonoApp({
+          kernel,
+          prefix: apiPath
+          // Use the calculated path
+        });
+        ctx.logger.debug("Mounting ObjectStack Runtime App", { prefix: apiPath });
+        this.server.mount("/", app);
+      } catch (e) {
+        ctx.logger.error("Failed to create standard Hono app", e);
+      }
+      if (this.options.staticRoot) {
+        const rawApp = this.server.getRawApp();
+        const staticRoot = this.options.staticRoot;
+        ctx.logger.debug("Configuring static files", { root: staticRoot, spa: this.options.spaFallback });
+        rawApp.get("/*", serveStatic2({ root: staticRoot }));
+        if (this.options.spaFallback) {
+          rawApp.get("*", async (c, next) => {
+            const config = this.options.restConfig || {};
+            const basePath = config.api?.basePath || "/api";
+            if (c.req.path.startsWith(basePath)) {
+              return next();
+            }
+            return serveStatic2({
+              root: staticRoot,
+              rewriteRequestPath: () => "index.html"
+            })(c, next);
+          });
+        }
+      }
+      ctx.hook("kernel:ready", async () => {
+        const port = this.options.port || 3e3;
+        ctx.logger.debug("Starting HTTP server", { port });
+        await this.server.listen(port);
+        const actualPort = this.server.getPort();
+        ctx.logger.info("HTTP server started successfully", {
+          port: actualPort,
+          url: `http://localhost:${actualPort}`
+        });
+      });
+    });
+    this.options = {
+      port: 3e3,
+      registerStandardEndpoints: true,
+      useApiRegistry: true,
+      spaFallback: false,
+      ...options
+    };
+    this.server = new HonoHttpServer(this.options.port);
+  }
+  /**
+   * Destroy phase - Stop server
+   */
+  async destroy() {
+    this.server.close();
+    console.log("[HonoServerPlugin] Server stopped");
+  }
+};
+// Constants
+__publicField(HonoServerPlugin, "DEFAULT_ENDPOINT_PRIORITY", 100);
+__publicField(HonoServerPlugin, "CORE_ENDPOINT_PRIORITY", 950);
+__publicField(HonoServerPlugin, "DISCOVERY_ENDPOINT_PRIORITY", 900);
+
+// src/index.ts
+__reExport(index_exports, adapter_exports);
+export {
+  HonoHttpServer,
+  HonoServerPlugin
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/adapter.ts","../src/hono-plugin.ts"],"sourcesContent":["export * from './hono-plugin';\nexport * from './adapter';\n\n","// Export IHttpServer from core\nexport * from '@objectstack/core';\n\nimport { \n    IHttpServer, \n    RouteHandler, \n    Middleware \n} from '@objectstack/core';\nimport { Hono } from 'hono';\nimport { serve } from '@hono/node-server';\nimport { serveStatic } from '@hono/node-server/serve-static';\n\n/**\n * Hono Implementation of IHttpServer\n */\nexport class HonoHttpServer implements IHttpServer {\n    private app: Hono;\n    private server: any;\n    private listeningPort: number | undefined;\n\n    constructor(\n        private port: number = 3000,\n        private staticRoot?: string\n    ) {\n        this.app = new Hono();\n    }\n\n    // internal helper to convert standard handler to Hono handler\n    private wrap(handler: RouteHandler) {\n        return async (c: any) => {\n            let body: any = {};\n            \n            // Try to parse JSON body first if content-type is JSON\n            if (c.req.header('content-type')?.includes('application/json')) {\n                try { \n                    body = await c.req.json(); \n                } catch(e) {\n                    // If JSON parsing fails, try parseBody\n                    try { \n                        body = await c.req.parseBody(); \n                    } catch(e2) {}\n                }\n            } else {\n                // For non-JSON content types, use parseBody\n                try { \n                    body = await c.req.parseBody(); \n                } catch(e) {}\n            }\n            \n            const req = {\n                params: c.req.param(),\n                query: c.req.query(),\n                body,\n                headers: c.req.header(),\n                method: c.req.method,\n                path: c.req.path\n            };\n\n            let capturedResponse: any;\n\n            const res = {\n                json: (data: any) => { capturedResponse = c.json(data); },\n                send: (data: string) => { capturedResponse = c.html(data); },\n                status: (code: number) => { c.status(code); return res; },\n                header: (name: string, value: string) => { c.header(name, value); return res; }\n            };\n\n            await handler(req as any, res as any);\n            return capturedResponse;\n        };\n    }\n\n    get(path: string, handler: RouteHandler) {\n        this.app.get(path, this.wrap(handler));\n    }\n    post(path: string, handler: RouteHandler) {\n        this.app.post(path, this.wrap(handler));\n    }\n    put(path: string, handler: RouteHandler) {\n        this.app.put(path, this.wrap(handler));\n    }\n    delete(path: string, handler: RouteHandler) {\n        this.app.delete(path, this.wrap(handler));\n    }\n    patch(path: string, handler: RouteHandler) {\n        this.app.patch(path, this.wrap(handler));\n    }\n    \n    use(pathOrHandler: string | Middleware, handler?: Middleware) {\n        if (typeof pathOrHandler === 'string' && handler) {\n             // Path based middleware\n             // Hono middleware signature is different (c, next) => ...\n             this.app.use(pathOrHandler, async (c, next) => {\n                 // Simplistic conversion\n                 await handler({} as any, {} as any, next);\n             });\n        } else if (typeof pathOrHandler === 'function') {\n             // Global middleware\n             this.app.use('*', async (c, next) => {\n                 await pathOrHandler({} as any, {} as any, next);\n             });\n        }\n    }\n\n    /**\n     * Mount a sub-application or router\n     */\n    mount(path: string, subApp: Hono) {\n        this.app.route(path, subApp);\n    }\n\n\n    async listen(port: number) {\n        return new Promise<void>((resolve) => {\n            if (this.staticRoot) {\n                this.app.get('/*', serveStatic({ root: this.staticRoot }));\n            }\n            \n            const targetPort = port || this.port;\n            this.server = serve({\n                fetch: this.app.fetch,\n                port: targetPort\n            }, (info) => {\n                this.listeningPort = info.port;\n                resolve();\n            });\n        });\n    }\n\n    getPort() {\n        return this.listeningPort || this.port;\n    }\n\n    // Expose raw app for scenarios where standard interface is not enough\n    getRawApp() {\n        return this.app;\n    }\n\n    async close() {\n        if (this.server && typeof this.server.close === 'function') {\n            this.server.close();\n        }\n    }\n\n\n}\n","import { Plugin, PluginContext, IHttpServer, ApiRegistry } from '@objectstack/core';\nimport { ObjectStackProtocol } from '@objectstack/spec/api';\nimport { \n    ApiRegistryEntryInput,\n    ApiEndpointRegistrationInput,\n    RestServerConfig,\n} from '@objectstack/spec/api';\nimport { HonoHttpServer } from './adapter';\nimport { createHonoApp } from '@objectstack/hono';\nimport { serveStatic } from '@hono/node-server/serve-static';\n\nexport interface HonoPluginOptions {\n    port?: number;\n    staticRoot?: string;\n    /**\n     * REST server configuration\n     * Controls automatic endpoint generation and API behavior\n     */\n    restConfig?: RestServerConfig;\n    /**\n     * Whether to register standard ObjectStack CRUD endpoints\n     * @default true\n     */\n    registerStandardEndpoints?: boolean;\n    /**\n     * Whether to load endpoints from API Registry\n     * @default true\n     */\n    useApiRegistry?: boolean;\n\n    /**\n     * Whether to enable SPA fallback\n     * If true, returns index.html for non-API 404s\n     * @default false\n     */\n    spaFallback?: boolean;\n}\n\n/**\n * Hono Server Plugin\n * \n * Provides HTTP server capabilities using Hono framework.\n * Registers routes for ObjectStack Runtime Protocol.\n */\nexport class HonoServerPlugin implements Plugin {\n    name = 'com.objectstack.server.hono';\n    version = '0.9.0';\n    \n    // Constants\n    private static readonly DEFAULT_ENDPOINT_PRIORITY = 100;\n    private static readonly CORE_ENDPOINT_PRIORITY = 950;\n    private static readonly DISCOVERY_ENDPOINT_PRIORITY = 900;\n    \n    private options: HonoPluginOptions;\n    private server: HonoHttpServer;\n\n    constructor(options: HonoPluginOptions = {}) {\n        this.options = { \n            port: 3000,\n            registerStandardEndpoints: true,\n            useApiRegistry: true,\n            spaFallback: false,\n            ...options\n        };\n        // We handle static root manually in start() to support SPA fallback\n        this.server = new HonoHttpServer(this.options.port);\n    }\n\n    /**\n     * Init phase - Setup HTTP server and register as service\n     */\n    init = async (ctx: PluginContext) => {\n        ctx.logger.debug('Initializing Hono server plugin', { \n            port: this.options.port,\n            staticRoot: this.options.staticRoot \n        });\n        \n        // Register HTTP server service as IHttpServer\n        // Register as 'http.server' to match core requirements\n        ctx.registerService('http.server', this.server);\n        // Alias 'http-server' for backward compatibility\n        ctx.registerService('http-server', this.server);\n        ctx.logger.debug('HTTP server service registered', { serviceName: 'http.server' });\n    }\n\n    /**\n     * Start phase - Bind routes and start listening\n     */\n    start = async (ctx: PluginContext) => {\n        ctx.logger.debug('Starting Hono server plugin');\n        \n        // Use Standard ObjectStack Runtime Hono App\n        try {\n            const kernel = ctx.getKernel();\n            const config = this.options.restConfig || {};\n            // Calculate prefix similar to before\n            const apiVersion = config.api?.version || 'v1';\n            const basePath = config.api?.basePath || '/api';\n            const apiPath = config.api?.apiPath || `${basePath}/${apiVersion}`;\n            \n            const app = createHonoApp({ \n                kernel,\n                prefix: apiPath // Use the calculated path\n            });\n            \n            ctx.logger.debug('Mounting ObjectStack Runtime App', { prefix: apiPath });\n            // Use the mount method we added to HonoHttpServer\n            this.server.mount('/', app as any);\n\n        } catch (e: any) {\n             ctx.logger.error('Failed to create standard Hono app', e);\n        }\n\n        // Configure Static Files & SPA Fallback\n        if (this.options.staticRoot) {\n            const rawApp = this.server.getRawApp();\n            const staticRoot = this.options.staticRoot;\n            \n            ctx.logger.debug('Configuring static files', { root: staticRoot, spa: this.options.spaFallback });\n            \n            // 1. Static Files\n            rawApp.get('/*', serveStatic({ root: staticRoot }));\n            \n            // 2. SPA Fallback\n            if (this.options.spaFallback) {\n                rawApp.get('*', async (c, next) => {\n                    // Skip API paths\n                    const config = this.options.restConfig || {};\n                    const basePath = config.api?.basePath || '/api';\n                    \n                    if (c.req.path.startsWith(basePath)) {\n                        return next();\n                    }\n                    \n                    // Fallback to index.html\n                    return serveStatic({ \n                        root: staticRoot,\n                        rewriteRequestPath: () => 'index.html'\n                    })(c, next);\n                });\n            }\n        }\n\n        // Start server on kernel:ready hook\n        ctx.hook('kernel:ready', async () => {\n            const port = this.options.port || 3000;\n            ctx.logger.debug('Starting HTTP server', { port });\n            \n            await this.server.listen(port);\n            \n            const actualPort = this.server.getPort();\n            ctx.logger.info('HTTP server started successfully', { \n                port: actualPort, \n                url: `http://localhost:${actualPort}` \n            });\n        });\n    }\n\n    /**\n     * Destroy phase - Stop server\n     */\n    async destroy() {\n        this.server.close();\n        // Note: Can't use ctx.logger here since we're in destroy\n        console.log('[HonoServerPlugin] Server stopped');\n    }\n}\n"],"mappings":"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","names":["serveStatic","serveStatic"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/plugin-hono-server",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "license": "Apache-2.0",
   "description": "Standard Hono Server Adapter for ObjectStack Runtime",
   "main": "dist/index.js",
@@ -8,11 +8,11 @@
   "dependencies": {
     "@hono/node-server": "^1.2.0",
     "hono": "^4.0.0",
-    "@objectstack/core": "1.0.2",
-    "@objectstack/hono": "1.0.2",
-    "@objectstack/runtime": "1.0.2",
-    "@objectstack/spec": "1.0.2",
-    "@objectstack/types": "1.0.2"
+    "@objectstack/core": "1.0.5",
+    "@objectstack/hono": "1.0.5",
+    "@objectstack/runtime": "1.0.5",
+    "@objectstack/spec": "1.0.5",
+    "@objectstack/types": "1.0.5"
   },
   "devDependencies": {
     "@types/node": "^25.1.0",
@@ -20,7 +20,7 @@
     "vitest": "^4.0.18"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsup --config ../../../tsup.config.ts",
     "test": "vitest run"
   }
 }

package/src/adapter.ts

@@ -16,6 +16,7 @@ import { serveStatic } from '@hono/node-server/serve-static';
 export class HonoHttpServer implements IHttpServer {
     private app: Hono;
     private server: any;
+    private listeningPort: number | undefined;
 
     constructor(
         private port: number = 3000,
@@ -115,15 +116,21 @@ export class HonoHttpServer implements IHttpServer {
                 this.app.get('/*', serveStatic({ root: this.staticRoot }));
             }
             
+            const targetPort = port || this.port;
             this.server = serve({
                 fetch: this.app.fetch,
-                port: port || this.port
+                port: targetPort
             }, (info) => {
+                this.listeningPort = info.port;
                 resolve();
             });
         });
     }
 
+    getPort() {
+        return this.listeningPort || this.port;
+    }
+
     // Expose raw app for scenarios where standard interface is not enough
     getRawApp() {
         return this.app;

package/src/hono-plugin.test.ts

@@ -9,13 +9,23 @@ vi.mock('@objectstack/hono', () => ({
     createHonoApp: vi.fn(),
 }));
 
+vi.mock('@hono/node-server/serve-static', () => ({
+    serveStatic: vi.fn(() => (c: any, next: any) => next())
+}));
+
 vi.mock('./adapter', () => ({
     HonoHttpServer: vi.fn(function() {
         return {
             mount: vi.fn(),
             start: vi.fn(),
             stop: vi.fn(),
-            getApp: vi.fn()
+            getApp: vi.fn(),
+            listen: vi.fn(),
+            getPort: vi.fn().mockReturnValue(3000),
+            close: vi.fn(),
+            getRawApp: vi.fn().mockReturnValue({
+                get: vi.fn(),
+            })
         };
     })
 }));
@@ -104,4 +114,23 @@ describe('HonoServerPlugin', () => {
         
         expect(logger.error).toHaveBeenCalledWith('Failed to create standard Hono app', expect.any(Error));
     });
+
+    it('should configure static files and SPA fallback when enabled', async () => {
+        const plugin = new HonoServerPlugin({
+            staticRoot: './public',
+            spaFallback: true
+        });
+
+        await plugin.init(context as PluginContext);
+        await plugin.start(context as PluginContext);
+
+        const serverInstance = (HonoHttpServer as any).mock.instances[0];
+        const rawApp = serverInstance.getRawApp();
+        
+        expect(serverInstance.getRawApp).toHaveBeenCalled();
+        // Should register static files middleware
+        expect(rawApp.get).toHaveBeenCalledWith('/*', expect.anything());
+        // Should register SPA fallback middleware
+        expect(rawApp.get).toHaveBeenCalledWith('*', expect.anything());
+    });
 });

package/src/hono-plugin.ts

@@ -7,6 +7,7 @@ import {
 } from '@objectstack/spec/api';
 import { HonoHttpServer } from './adapter';
 import { createHonoApp } from '@objectstack/hono';
+import { serveStatic } from '@hono/node-server/serve-static';
 
 export interface HonoPluginOptions {
     port?: number;
@@ -26,6 +27,13 @@ export interface HonoPluginOptions {
      * @default true
      */
     useApiRegistry?: boolean;
+
+    /**
+     * Whether to enable SPA fallback
+     * If true, returns index.html for non-API 404s
+     * @default false
+     */
+    spaFallback?: boolean;
 }
 
 /**
@@ -51,9 +59,11 @@ export class HonoServerPlugin implements Plugin {
             port: 3000,
             registerStandardEndpoints: true,
             useApiRegistry: true,
+            spaFallback: false,
             ...options
         };
-        this.server = new HonoHttpServer(this.options.port, this.options.staticRoot);
+        // We handle static root manually in start() to support SPA fallback
+        this.server = new HonoHttpServer(this.options.port);
     }
 
     /**
@@ -66,8 +76,11 @@ export class HonoServerPlugin implements Plugin {
         });
         
         // Register HTTP server service as IHttpServer
+        // Register as 'http.server' to match core requirements
+        ctx.registerService('http.server', this.server);
+        // Alias 'http-server' for backward compatibility
         ctx.registerService('http-server', this.server);
-        ctx.logger.info('HTTP server service registered', { serviceName: 'http-server' });
+        ctx.logger.debug('HTTP server service registered', { serviceName: 'http.server' });
     }
 
     /**
@@ -90,7 +103,7 @@ export class HonoServerPlugin implements Plugin {
                 prefix: apiPath // Use the calculated path
             });
             
-            ctx.logger.info('Mounting ObjectStack Runtime App', { prefix: apiPath });
+            ctx.logger.debug('Mounting ObjectStack Runtime App', { prefix: apiPath });
             // Use the mount method we added to HonoHttpServer
             this.server.mount('/', app as any);
 
@@ -98,15 +111,47 @@ export class HonoServerPlugin implements Plugin {
              ctx.logger.error('Failed to create standard Hono app', e);
         }
 
+        // Configure Static Files & SPA Fallback
+        if (this.options.staticRoot) {
+            const rawApp = this.server.getRawApp();
+            const staticRoot = this.options.staticRoot;
+            
+            ctx.logger.debug('Configuring static files', { root: staticRoot, spa: this.options.spaFallback });
+            
+            // 1. Static Files
+            rawApp.get('/*', serveStatic({ root: staticRoot }));
+            
+            // 2. SPA Fallback
+            if (this.options.spaFallback) {
+                rawApp.get('*', async (c, next) => {
+                    // Skip API paths
+                    const config = this.options.restConfig || {};
+                    const basePath = config.api?.basePath || '/api';
+                    
+                    if (c.req.path.startsWith(basePath)) {
+                        return next();
+                    }
+                    
+                    // Fallback to index.html
+                    return serveStatic({ 
+                        root: staticRoot,
+                        rewriteRequestPath: () => 'index.html'
+                    })(c, next);
+                });
+            }
+        }
+
         // Start server on kernel:ready hook
         ctx.hook('kernel:ready', async () => {
             const port = this.options.port || 3000;
-            ctx.logger.info('Starting HTTP server', { port });
+            ctx.logger.debug('Starting HTTP server', { port });
             
             await this.server.listen(port);
+            
+            const actualPort = this.server.getPort();
             ctx.logger.info('HTTP server started successfully', { 
-                port, 
-                url: `http://localhost:${port}` 
+                port: actualPort, 
+                url: `http://localhost:${actualPort}` 
             });
         });
     }

package/dist/adapter.d.ts

@@ -1,27 +0,0 @@
-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;
-    /**
-     * Mount a sub-application or router
-     */
-    mount(path: string, subApp: Hono): void;
-    listen(port: number): Promise<void>;
-    getRawApp(): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-    close(): Promise<void>;
-}

package/dist/adapter.js

@@ -1,139 +0,0 @@
-"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) => {
-            let body = {};
-            // Try to parse JSON body first if content-type is JSON
-            if (c.req.header('content-type')?.includes('application/json')) {
-                try {
-                    body = await c.req.json();
-                }
-                catch (e) {
-                    // If JSON parsing fails, try parseBody
-                    try {
-                        body = await c.req.parseBody();
-                    }
-                    catch (e2) { }
-                }
-            }
-            else {
-                // For non-JSON content types, use parseBody
-                try {
-                    body = await c.req.parseBody();
-                }
-                catch (e) { }
-            }
-            const req = {
-                params: c.req.param(),
-                query: c.req.query(),
-                body,
-                headers: c.req.header(),
-                method: c.req.method,
-                path: c.req.path
-            };
-            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);
-            });
-        }
-    }
-    /**
-     * Mount a sub-application or router
-     */
-    mount(path, subApp) {
-        this.app.route(path, subApp);
-    }
-    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;