@telorun/http-server 0.1.0

package/LICENSE

@@ -0,0 +1,17 @@
+# SUSTAINABLE USE LICENSE (Fair-code)
+
+Copyright (c) 2026 DiglyAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to use, copy, modify, and distribute the Software for any purpose—including commercial purposes—subject to the following conditions:
+
+1. ANTI-COMPETITION RESTRICTION: The Software may not be provided to third parties as a managed service, commercial SaaS (Software-as-a-Service), PaaS (Platform-as-a-Service), BaaS (Backend-as-a-Service), or similar offering where the primary value provided to the user is the functionality of the Software itself, without a separate commercial license from the copyright holder.
+
+2. PERMITTED COMMERCIAL USE: You are free to use the Software to build, host, and monetize your own commercial applications, products, and services, provided such use does not violate Clause 1.
+
+3. ATTRIBUTION: This copyright notice and license must be included in all copies or substantial portions of the Software.
+
+4. CONTRIBUTIONS: Contributions to the Software are welcome and encouraged. By contributing, you agree that your contributions may be incorporated into the Software and distributed under this license.
+
+5. DISCLAIMER: The Software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the Software or the use or other dealings in the Software.
+
+For commercial licensing, managed hosting exemptions, or enterprise inquiries, please contact DiglyAI.

package/dist/http-api-controller.d.ts

@@ -0,0 +1,47 @@
+import { ControllerContext, ResourceContext, ResourceInstance } from "@telorun/sdk";
+import { Static } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+declare const HttpApiManifest: import("@sinclair/typebox").TObject<{
+    routes: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        request: import("@sinclair/typebox").TObject<{
+            path: import("@sinclair/typebox").TString;
+            method: import("@sinclair/typebox").TString;
+            schema: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                params: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+                query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+                body: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+                headers: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+            }>>;
+        }>;
+        handler: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            kind: import("@sinclair/typebox").TString;
+            name: import("@sinclair/typebox").TString;
+            inputs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+        }>>;
+        response: import("@sinclair/typebox").TObject<{
+            status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString]>;
+            statuses: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+                schema: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                    query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+                    body: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+                    headers: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+                }>>;
+                headers: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+                body: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+            }>>;
+        }>;
+    }>>;
+}>;
+type HttpApiManifest = Static<typeof HttpApiManifest>;
+export declare function register(ctx: ControllerContext): Promise<void>;
+export declare class HttpServerApi implements ResourceInstance {
+    private readonly ctx;
+    readonly manifest: HttpApiManifest;
+    constructor(ctx: ResourceContext, manifest: HttpApiManifest);
+    init(): Promise<void>;
+    register(app: FastifyInstance, prefix?: string): void;
+    private registerRoutes;
+    private registerRoute;
+}
+export declare function create(resource: HttpApiManifest, ctx: ResourceContext): Promise<HttpServerApi>;
+export {};

package/dist/http-api-controller.js

@@ -0,0 +1,201 @@
+import { Type } from "@sinclair/typebox";
+const HttpApiRouteManifest = Type.Object({
+    request: Type.Object({
+        path: Type.String(),
+        method: Type.String(),
+        schema: Type.Optional(Type.Object({
+            params: Type.Optional(Type.Any()),
+            query: Type.Optional(Type.Any()),
+            body: Type.Optional(Type.Any()),
+            headers: Type.Optional(Type.Any()),
+        })),
+    }),
+    handler: Type.Optional(Type.Object({
+        kind: Type.String(),
+        name: Type.String(),
+        inputs: Type.Optional(Type.Any()),
+    })),
+    response: Type.Object({
+        status: Type.Union([Type.Number({ minimum: 100, maximum: 599 }), Type.String()]),
+        statuses: Type.Record(Type.String(), Type.Object({
+            schema: Type.Optional(Type.Object({
+                query: Type.Optional(Type.Any()),
+                body: Type.Optional(Type.Any()),
+                headers: Type.Optional(Type.Any()),
+            })),
+            headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+            body: Type.Optional(Type.Any()),
+        })),
+    }),
+});
+const HttpApiManifest = Type.Object({
+    routes: Type.Array(HttpApiRouteManifest),
+});
+export async function register(ctx) { }
+export class HttpServerApi {
+    ctx;
+    manifest;
+    constructor(ctx, manifest) {
+        this.ctx = ctx;
+        this.manifest = manifest;
+    }
+    async init() { }
+    register(app, prefix = "") {
+        if (prefix) {
+            app.register(async (scoped) => {
+                this.registerRoutes(scoped);
+            }, { prefix });
+        }
+        else {
+            this.registerRoutes(app);
+        }
+    }
+    registerRoutes(app) {
+        const routes = this.manifest.routes || [];
+        for (const route of routes) {
+            this.registerRoute(app, route);
+        }
+    }
+    registerRoute(app, route) {
+        const handler = route.handler ? resolveHandlerName(route.handler) : null;
+        const schema = {};
+        if (route.request.schema?.query) {
+            schema.querystring = route.request.schema?.query;
+        }
+        if (route.request.schema?.params) {
+            schema.params = route.request.schema?.params;
+        }
+        if (route.request.schema?.body) {
+            schema.body = route.request.schema?.body;
+        }
+        if (route.request.schema?.headers) {
+            schema.headers = route.request.schema?.headers;
+        }
+        schema.response = Object.keys(route.response.statuses).reduce((acc, status) => {
+            const statusConfig = route.response.statuses[status];
+            if (statusConfig.schema) {
+                acc[status] = {};
+                if (statusConfig.schema.query) {
+                    acc[status].querystring = statusConfig.schema.query;
+                }
+                if (statusConfig.schema.body) {
+                    acc[status].body = statusConfig.schema.body;
+                }
+                if (statusConfig.schema.headers) {
+                    acc[status].headers = statusConfig.schema.headers;
+                }
+            }
+            return acc;
+        }, {});
+        app.route({
+            method: route.request.method,
+            url: route.request.path,
+            schema,
+            handler: async (request, reply) => {
+                // const resolveSchema = createSchemaResolver(ctx);
+                const requestPayload = {
+                    params: request.params,
+                    query: request.query,
+                    body: request.body,
+                    headers: request.headers,
+                    method: request.method,
+                    url: request.url,
+                };
+                // validateRequestSchemas(route.request, requestPayload, resolveSchema);
+                const result = handler
+                    ? await this.ctx.invoke(handler.kind, handler.name, resolveHandlerInputs(route.handler, requestPayload))
+                    : undefined;
+                // Handle response with body/headers mapping
+                const response = route.response;
+                // Set status
+                const status = typeof response.status === "string"
+                    ? this.ctx.expandValue(response.status, { result })
+                    : response.status;
+                if (response.status) {
+                    reply.code(status);
+                }
+                const statusConfig = response.statuses[response.status];
+                if (!statusConfig) {
+                    return reply.code(500).send({ error: "Invalid response status configuration" });
+                }
+                // Map headers if specified
+                if (statusConfig.headers) {
+                    reply.headers(this.ctx.expandValue(statusConfig.headers, { result }));
+                }
+                // Map body if specified
+                if (statusConfig.body !== undefined) {
+                    const mappedBody = this.ctx.expandValue(statusConfig.body, {
+                        result,
+                    });
+                    if (statusConfig.schema && statusConfig.schema.body) {
+                        this.ctx.validateSchema(mappedBody, statusConfig.schema.body);
+                    }
+                    return reply.send(mappedBody);
+                }
+                // No body mapping, send result as-is
+                return reply.send(result);
+            },
+        });
+    }
+}
+export async function create(resource, ctx) {
+    ctx.validateSchema(resource, HttpApiManifest);
+    return new HttpServerApi(ctx, resource);
+}
+function resolveHandlerName(handler) {
+    if (typeof handler === "string") {
+        const [kind, name] = handler.split("/");
+        return { kind, name };
+    }
+    if (handler &&
+        typeof handler === "object" &&
+        typeof handler.name === "string" &&
+        typeof handler.kind === "string") {
+        return { name: handler.name, kind: handler.kind };
+    }
+    throw new Error("Unable to resolve handler");
+}
+function resolveHandlerInputs(handler, requestPayload) {
+    if (typeof handler === "string") {
+        return requestPayload;
+    }
+    if (!handler || typeof handler !== "object") {
+        return requestPayload;
+    }
+    if (!handler.inputs) {
+        return requestPayload;
+    }
+    const context = { request: requestPayload, ...requestPayload };
+    return resolveTemplateInputs(handler.inputs, context);
+}
+function resolveTemplateInputs(value, context) {
+    if (typeof value === "string") {
+        const match = value.match(/^\s*\$\{\{\s*([^}]+)\s*\}\}\s*$/);
+        if (match) {
+            return resolveTemplatePath(match[1], context);
+        }
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => resolveTemplateInputs(item, context));
+    }
+    if (value && typeof value === "object") {
+        const resolved = {};
+        for (const [key, entry] of Object.entries(value)) {
+            resolved[key] = resolveTemplateInputs(entry, context);
+        }
+        return resolved;
+    }
+    return value;
+}
+function resolveTemplatePath(pathExpression, context) {
+    const parts = pathExpression.trim().split(".").filter(Boolean);
+    let current = context;
+    for (const part of parts) {
+        if (!current || (typeof current !== "object" && typeof current !== "function")) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}

package/dist/http-server-controller.d.ts

@@ -0,0 +1,18 @@
+import type { ResourceContext, ResourceInstance, RuntimeResource } from "@telorun/sdk";
+type HttpServerResource = RuntimeResource & {
+    host?: string;
+    port?: number;
+    baseUrl?: string;
+    openapi?: {
+        info: {
+            title: string;
+            version: string;
+        };
+    };
+    mounts?: Array<{
+        path?: string;
+        type?: string;
+    }>;
+};
+export declare function create(resource: HttpServerResource, ctx: ResourceContext): ResourceInstance | null;
+export {};

package/dist/http-server-controller.js

@@ -0,0 +1,104 @@
+import swagger from "@fastify/swagger";
+import apiReference from "@scalar/fastify-api-reference";
+import Fastify from "fastify";
+class HttpServer {
+    releaseHold = null;
+    app;
+    host;
+    port;
+    baseUrl;
+    resource;
+    ctx;
+    constructor(resource, ctx) {
+        this.resource = resource;
+        this.ctx = ctx;
+        this.host = resource.host || "0.0.0.0";
+        this.port = Number(resource.port || 0);
+        this.baseUrl = resource.baseUrl ?? `http://${this.host}:${this.port}`;
+        if (!this.port) {
+            throw new Error("Http.Server port is required");
+        }
+        this.app = Fastify({ logger: true });
+    }
+    async init() {
+        this.setupPlugins();
+        this.setupRoutes();
+    }
+    async setupPlugins() {
+        if (this.resource.openapi) {
+            const servers = [];
+            // const routesByName = new Map<string, HttpRouteResource>();
+            const mounts = this.resource.mounts || [];
+            const prefixes = new Set();
+            for (const mount of mounts) {
+                prefixes.add(mount.path || "");
+            }
+            for (const prefix of prefixes) {
+                servers.push({ url: this.baseUrl + prefix });
+            }
+            await this.app.register(swagger, {
+                openapi: {
+                    openapi: "3.0.0",
+                    info: this.resource.openapi.info,
+                    servers,
+                },
+            });
+            await this.app.register(apiReference, {
+                routePrefix: "/reference",
+            });
+        }
+    }
+    setupRoutes() {
+        // const routesByName = new Map<string, HttpRouteResource>();
+        const mounts = this.resource.mounts || [];
+        // const resolveSchema = createSchemaResolver(this.ctx);
+        for (const mount of mounts) {
+            const type = mount.type || "";
+            const { kind, name } = parseType(type);
+            const prefix = mount.path || "";
+            const api = this.ctx.getResourcesByName(kind, name);
+            if (!api) {
+                throw new Error(`Failed to mount Http.Api at "${prefix}": ${type} not found`);
+            }
+            api.register(this.app, prefix);
+        }
+    }
+    async run() {
+        this.releaseHold = this.ctx.acquireHold();
+        try {
+            await this.app.listen({ host: this.host, port: this.port });
+            await this.ctx.emitEvent(`${this.resource.metadata.name}.Listening`, {
+                port: this.port,
+                host: this.host,
+                baseUrl: this.baseUrl,
+                mounts: this.resource.mounts,
+                openapi: this.resource.openapi,
+            });
+        }
+        catch (error) {
+            await this.app.close();
+            if (this.releaseHold) {
+                this.releaseHold();
+                this.releaseHold = null;
+            }
+            throw error;
+        }
+    }
+    async teardown() {
+        if (this.releaseHold) {
+            this.releaseHold();
+            this.releaseHold = null;
+        }
+        await this.app.close();
+    }
+}
+export function create(resource, ctx) {
+    return new HttpServer(resource, ctx);
+}
+function parseType(type) {
+    const separator = type.lastIndexOf(".");
+    if (separator <= 0 || separator === type.length - 1) {
+        return { kind: "", name: "" };
+    }
+    return { kind: type.slice(0, separator), name: type.slice(separator + 1) };
+}

package/dist/openapi.js

@@ -0,0 +1,152 @@
+import swagger from '@fastify/swagger';
+import apiReference from '@scalar/fastify-api-reference';
+function getResourceConfig(resource) {
+    return resource;
+}
+export function register(ctx) { }
+export function create(resource, ctx) {
+    const openApiResource = resource;
+    const config = getResourceConfig(openApiResource);
+    const apiRefs = config.apis || [];
+    if (apiRefs.length === 0) {
+        throw new Error(`OpenApi.Spec "${resource.metadata.name}" is missing apis`);
+    }
+    const handler = (payload) => {
+        const serverResource = payload?.resource;
+        const app = payload?.app;
+        if (!serverResource || !app) {
+            throw new Error(`OpenApi.Spec handler missing Http.Server resource or Fastify app`);
+        }
+        const matchedApis = resolveApis(apiRefs, ctx);
+        const mounts = getResourceConfig(serverResource).mounts || [];
+        const servers = buildServers(serverResource, mounts, matchedApis);
+        if (servers.length === 0) {
+            return;
+        }
+        const paths = buildPaths(matchedApis, mounts);
+        const info = config.info && typeof config.info === 'object'
+            ? config.info
+            : {
+                title: resource.metadata.name,
+                version: resource.version || '1.0.0',
+            };
+        const routePrefix = config.path || `/openapi/${resource.metadata.name}`;
+        app.register(swagger, {
+            openapi: {
+                openapi: '3.0.0',
+                info,
+                servers,
+                paths,
+            },
+            routePrefix,
+        });
+        app.register(apiReference, {
+            routePrefix,
+        });
+    };
+    const httpServers = ctx.getResources('Http.Server');
+    return {
+        init: async () => {
+            // Register listeners after all resources are initialized
+            for (const server of httpServers) {
+                ctx.on('Http.Server.Ready', server.metadata.name, handler);
+            }
+        },
+        teardown: () => {
+            for (const server of httpServers) {
+                ctx.offResourceEvent('Http.Server', server.metadata.name, 'Ready', handler);
+            }
+        },
+    };
+}
+function resolveApis(apiRefs, ctx) {
+    const apis = [];
+    for (const ref of apiRefs) {
+        const { kind, name } = parseRef(ref);
+        if (!kind || !name) {
+            throw new Error(`Reference not found: ${ref}`);
+        }
+        if (kind !== 'Http.Api' && kind !== 'Http.Route') {
+            throw new Error(`Reference not supported: ${ref}`);
+        }
+        const resource = ctx.kernel.registry.get(kind)?.get(name);
+        if (!resource) {
+            throw new Error(`Reference not found: ${ref}`);
+        }
+        apis.push(resource);
+    }
+    return apis;
+}
+function buildServers(server, mounts, apis) {
+    const config = getResourceConfig(server);
+    const host = config.host || '0.0.0.0';
+    const port = Number(config.port || 0);
+    if (!port) {
+        return [];
+    }
+    // Server URL should be the base URL without mount paths
+    // Paths will include the mount prefix
+    return [{ url: `http://${host}:${port}` }];
+}
+function buildPaths(apis, mounts) {
+    const paths = {};
+    const mountPrefixByType = new Map();
+    for (const mount of mounts) {
+        if (mount.type) {
+            mountPrefixByType.set(mount.type, mount.path || '');
+        }
+    }
+    for (const api of apis) {
+        const prefix = mountPrefixByType.get(`${api.kind}.${api.metadata.name}`) || '';
+        if (api.kind === 'Http.Route') {
+            const config = getResourceConfig(api);
+            const path = joinPath(prefix, api.metadata?.path || config.path || '');
+            const method = (api.metadata?.method ||
+                config.method ||
+                'GET').toLowerCase();
+            if (!path) {
+                continue;
+            }
+            if (!paths[path]) {
+                paths[path] = {};
+            }
+            paths[path][method] = { responses: { '200': { description: 'OK' } } };
+            continue;
+        }
+        const routes = getResourceConfig(api).routes || [];
+        for (const route of routes) {
+            if (typeof route === 'string') {
+                continue;
+            }
+            const request = route.request || {};
+            const path = joinPath(prefix, request.path || '');
+            const method = (request.method || 'GET').toLowerCase();
+            if (!path) {
+                continue;
+            }
+            if (!paths[path]) {
+                paths[path] = {};
+            }
+            paths[path][method] = { responses: { '200': { description: 'OK' } } };
+        }
+    }
+    return paths;
+}
+function parseRef(ref) {
+    const separator = ref.lastIndexOf('.');
+    if (separator <= 0 || separator === ref.length - 1) {
+        return { kind: '', name: '' };
+    }
+    return { kind: ref.slice(0, separator), name: ref.slice(separator + 1) };
+}
+function joinPath(prefix, path) {
+    if (!prefix) {
+        return path;
+    }
+    if (!path) {
+        return prefix;
+    }
+    const trimmedPrefix = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    const trimmedPath = path.startsWith('/') ? path : `/${path}`;
+    return `${trimmedPrefix}${trimmedPath}`;
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@telorun/http-server",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "exports": {
+    "./http-server": {
+      "types": "./dist/http-server-controller.d.ts",
+      "bun": "./src/http-server-controller.ts",
+      "import": "./dist/http-server-controller.js"
+    },
+    "./http-server-api": {
+      "types": "./dist/http-api-controller.d.ts",
+      "bun": "./src/http-api-controller.ts",
+      "import": "./dist/http-api-controller.js"
+    }
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.48",
+    "ajv": "^8.17.1",
+    "fastify": "^5.7.2",
+    "@fastify/swagger": "^9.6.1",
+    "@scalar/fastify-api-reference": "^1.44.6",
+    "@telorun/sdk": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.lib.json"
+  }
+}

package/src/http-api-controller.ts

@@ -0,0 +1,243 @@
+import { ControllerContext, ResourceContext, ResourceInstance } from "@telorun/sdk";
+import { Static, Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+
+const HttpApiRouteManifest = Type.Object({
+  request: Type.Object({
+    path: Type.String(),
+    method: Type.String(),
+    schema: Type.Optional(
+      Type.Object({
+        params: Type.Optional(Type.Any()),
+        query: Type.Optional(Type.Any()),
+        body: Type.Optional(Type.Any()),
+        headers: Type.Optional(Type.Any()),
+      }),
+    ),
+  }),
+  handler: Type.Optional(Type.Object({
+    kind: Type.String(),
+    name: Type.String(),
+    inputs: Type.Optional(Type.Any()),
+  })),
+  response: Type.Object({
+    status: Type.Union([Type.Number({ minimum: 100, maximum: 599 }), Type.String()]),
+    statuses: Type.Record(
+      Type.String(),
+      Type.Object({
+        schema: Type.Optional(
+          Type.Object({
+            query: Type.Optional(Type.Any()),
+            body: Type.Optional(Type.Any()),
+            headers: Type.Optional(Type.Any()),
+          }),
+        ),
+        headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+        body: Type.Optional(Type.Any()),
+      }),
+    ),
+  }),
+});
+type HttpApiRouteManifest = Static<typeof HttpApiRouteManifest>;
+
+const HttpApiManifest = Type.Object({
+  routes: Type.Array(HttpApiRouteManifest),
+});
+type HttpApiManifest = Static<typeof HttpApiManifest>;
+
+export async function register(ctx: ControllerContext): Promise<void> {}
+
+export class HttpServerApi implements ResourceInstance {
+  constructor(
+    private readonly ctx: ResourceContext,
+    readonly manifest: HttpApiManifest,
+  ) {}
+
+  async init() {}
+
+  register(app: FastifyInstance, prefix = "") {
+    if (prefix) {
+      app.register(
+        async (scoped) => {
+          this.registerRoutes(scoped);
+        },
+        { prefix },
+      );
+    } else {
+      this.registerRoutes(app);
+    }
+  }
+
+  private registerRoutes(app: FastifyInstance) {
+    const routes = this.manifest.routes || [];
+    for (const route of routes) {
+      this.registerRoute(app, route);
+    }
+  }
+
+  private registerRoute(app: FastifyInstance, route: HttpApiRouteManifest) {
+    const handler = route.handler ? resolveHandlerName(route.handler) : null;
+    const schema: any = {};
+    if (route.request.schema?.query) {
+      schema.querystring = route.request.schema?.query;
+    }
+    if (route.request.schema?.params) {
+      schema.params = route.request.schema?.params;
+    }
+    if (route.request.schema?.body) {
+      schema.body = route.request.schema?.body;
+    }
+    if (route.request.schema?.headers) {
+      schema.headers = route.request.schema?.headers;
+    }
+    schema.response = Object.keys(route.response.statuses).reduce(
+      (acc, status) => {
+        const statusConfig = route.response.statuses[status];
+        if (statusConfig.schema) {
+          acc[status] = {};
+          if (statusConfig.schema.query) {
+            acc[status].querystring = statusConfig.schema.query;
+          }
+          if (statusConfig.schema.body) {
+            acc[status].body = statusConfig.schema.body;
+          }
+          if (statusConfig.schema.headers) {
+            acc[status].headers = statusConfig.schema.headers;
+          }
+        }
+        return acc;
+      },
+      {} as Record<string, any>,
+    );
+
+    app.route({
+      method: route.request.method,
+      url: route.request.path,
+      schema,
+      handler: async (request, reply) => {
+        // const resolveSchema = createSchemaResolver(ctx);
+        const requestPayload = {
+          params: request.params,
+          query: request.query,
+          body: request.body,
+          headers: request.headers,
+          method: request.method,
+          url: request.url,
+        };
+        // validateRequestSchemas(route.request, requestPayload, resolveSchema);
+        const result = handler
+          ? await this.ctx.invoke(
+              handler.kind,
+              handler.name,
+              resolveHandlerInputs(route.handler, requestPayload),
+            )
+          : undefined;
+        // Handle response with body/headers mapping
+
+        const response = route.response;
+
+        // Set status
+        const status =
+          typeof response.status === "string"
+            ? this.ctx.expandValue(response.status, { result })
+            : response.status;
+        if (response.status) {
+          reply.code(status);
+        }
+        const statusConfig = response.statuses[response.status];
+        if (!statusConfig) {
+          return reply.code(500).send({ error: "Invalid response status configuration" });
+        }
+        // Map headers if specified
+        if (statusConfig.headers) {
+          reply.headers(this.ctx.expandValue(statusConfig.headers, { result }));
+        }
+
+        // Map body if specified
+        if (statusConfig.body !== undefined) {
+          const mappedBody = this.ctx.expandValue(statusConfig.body, {
+            result,
+          });
+          if (statusConfig.schema && statusConfig.schema.body) {
+            this.ctx.validateSchema(mappedBody, statusConfig.schema.body);
+          }
+          return reply.send(mappedBody);
+        }
+
+        // No body mapping, send result as-is
+        return reply.send(result);
+      },
+    });
+  }
+}
+
+export async function create(
+  resource: HttpApiManifest,
+  ctx: ResourceContext,
+): Promise<HttpServerApi> {
+  ctx.validateSchema(resource, HttpApiManifest);
+  return new HttpServerApi(ctx, resource);
+}
+
+function resolveHandlerName(handler: any): { kind: string; name: string } {
+  if (typeof handler === "string") {
+    const [kind, name] = handler.split("/");
+    return { kind, name };
+  }
+  if (
+    handler &&
+    typeof handler === "object" &&
+    typeof handler.name === "string" &&
+    typeof handler.kind === "string"
+  ) {
+    return { name: handler.name, kind: handler.kind };
+  }
+  throw new Error("Unable to resolve handler");
+}
+
+function resolveHandlerInputs(handler: any, requestPayload: Record<string, any>): any {
+  if (typeof handler === "string") {
+    return requestPayload;
+  }
+  if (!handler || typeof handler !== "object") {
+    return requestPayload;
+  }
+  if (!handler.inputs) {
+    return requestPayload;
+  }
+  const context = { request: requestPayload, ...requestPayload };
+  return resolveTemplateInputs(handler.inputs, context);
+}
+
+function resolveTemplateInputs(value: any, context: Record<string, any>): any {
+  if (typeof value === "string") {
+    const match = value.match(/^\s*\$\{\{\s*([^}]+)\s*\}\}\s*$/);
+    if (match) {
+      return resolveTemplatePath(match[1], context);
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveTemplateInputs(item, context));
+  }
+  if (value && typeof value === "object") {
+    const resolved: Record<string, any> = {};
+    for (const [key, entry] of Object.entries(value)) {
+      resolved[key] = resolveTemplateInputs(entry, context);
+    }
+    return resolved;
+  }
+  return value;
+}
+
+function resolveTemplatePath(pathExpression: string, context: Record<string, any>): any {
+  const parts = pathExpression.trim().split(".").filter(Boolean);
+  let current: any = context;
+  for (const part of parts) {
+    if (!current || (typeof current !== "object" && typeof current !== "function")) {
+      return undefined;
+    }
+    current = current[part];
+  }
+  return current;
+}

package/src/http-server-controller.ts

@@ -0,0 +1,183 @@
+import swagger from "@fastify/swagger";
+import apiReference from "@scalar/fastify-api-reference";
+import type { ResourceContext, ResourceInstance, RuntimeResource } from "@telorun/sdk";
+import Fastify, { FastifyInstance } from "fastify";
+import { HttpServerApi } from "./http-api-controller.js";
+
+type HttpRouteResource = RuntimeResource & {
+  metadata?: { path?: string; method?: string };
+  path?: string;
+  method?: string;
+  handler?: HttpHandlerSpec;
+  request?: HttpRequestSchema;
+  response?: {
+    status?: number;
+    headers?: Record<string, string>;
+    body?: any;
+  };
+};
+
+type HttpServerResource = RuntimeResource & {
+  host?: string;
+  port?: number;
+  baseUrl?: string;
+  openapi?: {
+    info: {
+      title: string;
+      version: string;
+    };
+  };
+  mounts?: Array<{
+    path?: string;
+    type?: string;
+  }>;
+};
+
+type HttpApiResource = RuntimeResource & {
+  routes?: Array<
+    | string
+    | {
+        request?: {
+          path?: string;
+          method?: string;
+          query?: Record<string, any>;
+          body?: Record<string, any>;
+          headers?: Record<string, any>;
+        };
+        handler?: HttpHandlerSpec;
+        response?: {
+          status?: number;
+          headers?: Record<string, string>;
+          body?: any;
+        };
+      }
+  >;
+};
+
+type HttpHandlerSpec =
+  | string
+  | {
+      name?: string;
+      inputs?: Record<string, any>;
+    };
+
+type HttpRequestSchema = {
+  query?: Record<string, any>;
+  body?: Record<string, any>;
+  headers?: Record<string, any>;
+};
+
+class HttpServer implements ResourceInstance {
+  private releaseHold: (() => void) | null = null;
+  private readonly app: FastifyInstance;
+  private readonly host: string;
+  private readonly port: number;
+  private readonly baseUrl: string;
+  private readonly resource: HttpServerResource;
+  private readonly ctx: ResourceContext;
+
+  constructor(resource: HttpServerResource, ctx: ResourceContext) {
+    this.resource = resource;
+    this.ctx = ctx;
+    this.host = resource.host || "0.0.0.0";
+    this.port = Number(resource.port || 0);
+    this.baseUrl = resource.baseUrl ?? `http://${this.host}:${this.port}`;
+
+    if (!this.port) {
+      throw new Error("Http.Server port is required");
+    }
+    this.app = Fastify({ logger: true });
+  }
+
+  async init() {
+    this.setupPlugins();
+    this.setupRoutes();
+  }
+
+  private async setupPlugins() {
+    if (this.resource.openapi) {
+      const servers = [];
+      // const routesByName = new Map<string, HttpRouteResource>();
+      const mounts = this.resource.mounts || [];
+      const prefixes = new Set();
+      for (const mount of mounts) {
+        prefixes.add(mount.path || "");
+      }
+      for (const prefix of prefixes) {
+        servers.push({ url: this.baseUrl + prefix });
+      }
+      await this.app.register(swagger, {
+        openapi: {
+          openapi: "3.0.0",
+          info: this.resource.openapi.info,
+          servers,
+        },
+      });
+      await this.app.register(apiReference, {
+        routePrefix: "/reference",
+      });
+    }
+  }
+
+  private setupRoutes(): void {
+    // const routesByName = new Map<string, HttpRouteResource>();
+    const mounts = this.resource.mounts || [];
+    // const resolveSchema = createSchemaResolver(this.ctx);
+    for (const mount of mounts) {
+      const type = mount.type || "";
+      const { kind, name } = parseType(type);
+      const prefix = mount.path || "";
+
+      const api: HttpServerApi = this.ctx.getResourcesByName(kind, name) as any;
+
+      if (!api) {
+        throw new Error(`Failed to mount Http.Api at "${prefix}": ${type} not found`);
+      }
+      api.register(this.app, prefix);
+    }
+  }
+
+  async run(): Promise<void> {
+    this.releaseHold = this.ctx.acquireHold();
+    try {
+      await this.app.listen({ host: this.host, port: this.port });
+      await this.ctx.emitEvent(`${this.resource.metadata.name}.Listening`, {
+        port: this.port,
+        host: this.host,
+        baseUrl: this.baseUrl,
+        mounts: this.resource.mounts,
+        openapi: this.resource.openapi,
+      });
+    } catch (error) {
+      await this.app.close();
+      if (this.releaseHold) {
+        this.releaseHold();
+        this.releaseHold = null;
+      }
+      throw error;
+    }
+  }
+
+  async teardown(): Promise<void> {
+    if (this.releaseHold) {
+      this.releaseHold();
+      this.releaseHold = null;
+    }
+    await this.app.close();
+  }
+}
+
+export function create(
+  resource: HttpServerResource,
+  ctx: ResourceContext,
+): ResourceInstance | null {
+  return new HttpServer(resource, ctx);
+}
+
+function parseType(type: string): { kind: string; name: string } {
+  const separator = type.lastIndexOf(".");
+  if (separator <= 0 || separator === type.length - 1) {
+    return { kind: "", name: "" };
+  }
+  return { kind: type.slice(0, separator), name: type.slice(separator + 1) };
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "files": [],
+  "include": ["src/**/*.ts", "test/**/*.ts"],
+  "compilerOptions": {
+    "strict": true,
+    "esModuleInterop": true
+  },
+  "references": [
+    {
+      "path": "tsconfig.lib.json"
+    },
+    {
+      "path": "tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"],
+  "include": ["src/**/*.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "strict": true,
+    "esModuleInterop": true,
+    "types": ["node", "jest"]
+  },
+  "files": [],
+  "include": ["test/**/*.ts"]
+}