vitek-plugin 0.1.2-beta.6 → 0.2.0-beta

package/dist/cli/mcp-project-config.d.ts

@@ -0,0 +1,8 @@
+export interface VitekMcpConfig {
+    apiDir: string;
+    apiBasePath: string;
+    socketBasePath: string;
+    baseUrl: string;
+}
+export declare function loadMcpConfig(root: string): VitekMcpConfig;
+//# sourceMappingURL=mcp-project-config.d.ts.map

package/dist/cli/mcp-project-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-project-config.d.ts","sourceRoot":"","sources":["../../src/cli/mcp-project-config.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB;AASD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAgB1D"}

package/dist/cli/mcp-project-config.js

@@ -0,0 +1,26 @@
+import * as fs from 'fs';
+import * as path from 'path';
+const DEFAULT_CONFIG = {
+    apiDir: 'src/api',
+    apiBasePath: '/api',
+    socketBasePath: '/api/ws',
+    baseUrl: 'http://localhost:5173',
+};
+export function loadMcpConfig(root) {
+    const configPath = path.join(root, 'vitek.mcp.json');
+    if (!fs.existsSync(configPath)) {
+        return { ...DEFAULT_CONFIG };
+    }
+    try {
+        const raw = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        return {
+            apiDir: raw.apiDir ?? DEFAULT_CONFIG.apiDir,
+            apiBasePath: raw.apiBasePath ?? DEFAULT_CONFIG.apiBasePath,
+            socketBasePath: raw.socketBasePath ?? DEFAULT_CONFIG.socketBasePath,
+            baseUrl: raw.baseUrl ?? DEFAULT_CONFIG.baseUrl,
+        };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}

package/dist/cli/mcp-project.d.ts

@@ -0,0 +1,2 @@
+export declare function runMcpProject(): Promise<void>;
+//# sourceMappingURL=mcp-project.d.ts.map

package/dist/cli/mcp-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-project.d.ts","sourceRoot":"","sources":["../../src/cli/mcp-project.ts"],"names":[],"mappings":"AAgBA,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CA+HnD"}

package/dist/cli/mcp-project.js

@@ -0,0 +1,101 @@
+import * as path from 'path';
+import { getManifest } from '../core/introspection/manifest.js';
+import { generateOpenApiSpec } from '../core/openapi/generate.js';
+import { generateAsyncApiSpec } from '../core/asyncapi/generate.js';
+import { loadMcpConfig } from './mcp-project-config.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+const MANIFEST_URI = 'vitek-api://manifest';
+const ROUTES_URI = 'vitek-api://routes';
+const SOCKETS_URI = 'vitek-api://sockets';
+const OPENAPI_URI = 'vitek-api://openapi';
+const ASYNCAPI_URI = 'vitek-api://asyncapi';
+export async function runMcpProject() {
+    const root = process.cwd();
+    const config = loadMcpConfig(root);
+    const server = new McpServer({ name: 'vitek-api', version: '0.1.0' }, { capabilities: { resources: {}, tools: {} } });
+    function getManifestData() {
+        return getManifest(root, config.apiDir);
+    }
+    server.registerResource('vitek-api-manifest', MANIFEST_URI, { title: 'Vitek API manifest', description: 'Full manifest (routes, middlewares, sockets)', mimeType: 'application/json' }, async () => {
+        const manifest = getManifestData();
+        return { contents: [{ uri: MANIFEST_URI, text: JSON.stringify(manifest, null, 2) }] };
+    });
+    server.registerResource('vitek-api-routes', ROUTES_URI, { title: 'Vitek API routes', description: 'List of HTTP routes', mimeType: 'application/json' }, async () => {
+        const manifest = getManifestData();
+        return { contents: [{ uri: ROUTES_URI, text: JSON.stringify(manifest.routes, null, 2) }] };
+    });
+    server.registerResource('vitek-api-sockets', SOCKETS_URI, { title: 'Vitek API sockets', description: 'List of WebSocket routes', mimeType: 'application/json' }, async () => {
+        const manifest = getManifestData();
+        return { contents: [{ uri: SOCKETS_URI, text: JSON.stringify(manifest.sockets, null, 2) }] };
+    });
+    server.registerResource('vitek-api-openapi', OPENAPI_URI, { title: 'OpenAPI spec', description: 'OpenAPI 3.0 spec for HTTP API', mimeType: 'application/json' }, async () => {
+        const manifest = getManifestData();
+        const routesForDocs = manifest.routes.map((r) => ({
+            pattern: r.pattern,
+            method: r.method,
+            params: r.params,
+            file: path.join(root, r.file),
+        }));
+        const spec = generateOpenApiSpec(routesForDocs, { apiBasePath: config.apiBasePath });
+        return { contents: [{ uri: OPENAPI_URI, text: JSON.stringify(spec, null, 2) }] };
+    });
+    server.registerResource('vitek-api-asyncapi', ASYNCAPI_URI, { title: 'AsyncAPI spec', description: 'AsyncAPI 2.x spec for WebSockets', mimeType: 'application/json' }, async () => {
+        const manifest = getManifestData();
+        const socketsForDocs = manifest.sockets.map((s) => ({ pattern: s.pattern }));
+        const spec = generateAsyncApiSpec(socketsForDocs, config.socketBasePath, {});
+        return { contents: [{ uri: ASYNCAPI_URI, text: JSON.stringify(spec, null, 2) }] };
+    });
+    server.registerTool('vitek_api_call', {
+        title: 'Call project API',
+        description: 'Calls an endpoint of the local Vitek API. Requires the API to be running (e.g. pnpm dev or pnpm start). baseUrl defaults to config or http://localhost:5173.',
+        inputSchema: {
+            method: z.enum(['get', 'post', 'put', 'patch', 'delete', 'head', 'options']).describe('HTTP method'),
+            path: z.string().describe('Path relative to API base, e.g. health or users/1'),
+            body: z.any().optional().describe('Request body (for POST/PUT/PATCH)'),
+            headers: z.record(z.string()).optional().describe('Additional headers'),
+        },
+    }, async ({ method, path: pathArg, body, headers }) => {
+        const baseUrl = config.baseUrl.replace(/\/+$/, '');
+        const apiPath = pathArg.startsWith('/') ? pathArg : `/${pathArg}`;
+        const url = `${baseUrl}${config.apiBasePath}${apiPath}`;
+        try {
+            const res = await fetch(url, {
+                method: method.toUpperCase(),
+                headers: { 'Content-Type': 'application/json', ...headers },
+                body: body != null ? JSON.stringify(body) : undefined,
+            });
+            const text = await res.text();
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                parsed = text;
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Status: ${res.status}\nBody: ${JSON.stringify(parsed, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Request failed. Is the API running at ${baseUrl}? ${message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/cli/serve.d.ts

@@ -3,5 +3,31 @@
  * Usage: vitek-serve [--dir=dist] [--port=3000] [--host=0.0.0.0]
  *        Also accepts space-separated: --dir dist --port 3000 --host 0.0.0.0
  */
-export {};
+import * as http from 'http';
+import type { ApiClient, SocketEmitter } from '../core/shared/vitek-app.js';
+export type BeforeApiRequestHook = import('../core/server/request-handler.js').BeforeApiRequestHook;
+export interface OnServerStartContext {
+    api: ApiClient;
+    sockets: SocketEmitter;
+    server: http.Server;
+}
+export type OnServerStartHook = (ctx: OnServerStartContext) => void | Promise<void>;
+export type OnServerShutdownHook = () => void | Promise<void>;
+export interface ProductionConfig {
+    beforeApiRequest?: BeforeApiRequestHook[];
+    onError?: (err: Error, req: http.IncomingMessage, res: http.ServerResponse) => void | Promise<void>;
+    onServerStart?: OnServerStartHook;
+    onServerShutdown?: OnServerShutdownHook;
+    maxBodySize?: number;
+}
+/** Load beforeApiRequest, onError, onServerStart, onServerShutdown from dist/vitek.config.mjs if present. Throws if file exists but import fails. */
+export declare function loadProductionConfig(distDir: string): Promise<ProductionConfig>;
+export declare function parseArgs(): {
+    dir: string;
+    port: number;
+    host: string;
+    cors: boolean;
+    trustProxy: boolean;
+};
+export declare function main(): Promise<void>;
 //# sourceMappingURL=serve.d.ts.map

package/dist/cli/serve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../src/cli/serve.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../src/cli/serve.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAW7B,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAY,MAAM,6BAA6B,CAAC;AAItF,MAAM,MAAM,oBAAoB,GAAG,OAAO,mCAAmC,EAAE,oBAAoB,CAAC;AAEpG,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,SAAS,CAAC;IACf,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,GAAG,EAAE,oBAAoB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AACpF,MAAM,MAAM,oBAAoB,GAAG,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE9D,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,CAAC,EAAE,oBAAoB,EAAE,CAAC;IAC1C,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpG,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,gBAAgB,CAAC,EAAE,oBAAoB,CAAC;IACxC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qJAAqJ;AACrJ,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAoBrF;AAED,wBAAgB,SAAS,IAAI;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAsB3G;AAED,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAiI1C"}

package/dist/cli/serve.js

@@ -14,10 +14,38 @@ import { createSocketHandler } from '../core/socket/socket-handler.js';
 import { API_BASE_PATH, getSocketBasePath } from '../shared/constants.js';
 import { getApiBundleFilename } from '../build/build-api-bundle.js';
 import { getSocketsBundleFilename } from '../build/build-sockets-bundle.js';
-function parseArgs() {
+const VITEK_SERVE_CONFIG_FILENAME = 'vitek.config.mjs';
+/** Load beforeApiRequest, onError, onServerStart, onServerShutdown from dist/vitek.config.mjs if present. Throws if file exists but import fails. */
+export async function loadProductionConfig(distDir) {
+    const configPath = path.join(distDir, VITEK_SERVE_CONFIG_FILENAME);
+    if (!fs.existsSync(configPath))
+        return {};
+    const configUrl = pathToFileURL(configPath).href;
+    const configMod = await import(configUrl);
+    const result = {};
+    if (configMod.beforeApiRequest) {
+        result.beforeApiRequest = Array.isArray(configMod.beforeApiRequest) ? configMod.beforeApiRequest : [configMod.beforeApiRequest];
+    }
+    if (configMod.onError)
+        result.onError = configMod.onError;
+    if (configMod.onServerStart)
+        result.onServerStart = configMod.onServerStart;
+    if (configMod.onServerShutdown)
+        result.onServerShutdown = configMod.onServerShutdown;
+    if (configMod.maxBodySize != null)
+        result.maxBodySize = configMod.maxBodySize;
+    return result;
+}
+export function parseArgs() {
     let dir = 'dist';
-    let port = 3000;
-    let host = '0.0.0.0';
+    const portEnv = process.env.PORT;
+    const hostEnv = process.env.HOST;
+    let port = portEnv !== undefined && portEnv !== '' ? parseInt(portEnv, 10) : 3000;
+    if (Number.isNaN(port))
+        port = 3000;
+    let host = hostEnv !== undefined && hostEnv !== '' ? hostEnv : '0.0.0.0';
+    let cors = false;
+    let trustProxy = false;
     const argv = process.argv.slice(2);
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
@@ -33,11 +61,15 @@ function parseArgs() {
             host = arg.slice(7);
         else if (arg === '--host' && argv[i + 1])
             host = argv[++i];
+        else if (arg === '--cors')
+            cors = true;
+        else if (arg === '--trust-proxy')
+            trustProxy = true;
     }
-    return { dir, port, host };
+    return { dir, port, host, cors, trustProxy };
 }
-async function main() {
-    const { dir, port, host } = parseArgs();
+export async function main() {
+    const { dir, port, host, cors, trustProxy } = parseArgs();
     const distDir = path.resolve(process.cwd(), dir);
     if (!fs.existsSync(distDir) || !fs.statSync(distDir).isDirectory()) {
         console.error(`[vitek-serve] Directory not found or not a directory: ${distDir}`);
@@ -71,6 +103,14 @@ async function main() {
     const shared = { sockets: noopSockets, api };
     const app = connect();
     const bundlePath = path.join(distDir, getApiBundleFilename());
+    let productionConfig = {};
+    try {
+        productionConfig = await loadProductionConfig(distDir);
+    }
+    catch (err) {
+        console.warn('[vitek-serve] Failed to load vitek.config.mjs; continuing without production hooks:', err instanceof Error ? err.message : String(err));
+    }
+    const { beforeApiRequest, onError, onServerStart, onServerShutdown, maxBodySize } = productionConfig;
     if (fs.existsSync(bundlePath)) {
         try {
             const bundleUrl = pathToFileURL(bundlePath).href;
@@ -78,6 +118,11 @@ async function main() {
             const apiHandler = createRequestHandler({
                 routes: mod.routes,
                 middlewares: mod.middlewares,
+                beforeApiRequest,
+                cors: cors ? true : undefined,
+                trustProxy,
+                maxBodySize,
+                onError,
                 shared,
             });
             app.use(apiHandler);
@@ -119,12 +164,42 @@ async function main() {
             console.warn('[vitek-serve] Failed to load sockets bundle:', err instanceof Error ? err.message : String(err));
         }
     }
+    if (onServerStart) {
+        try {
+            await Promise.resolve(onServerStart({ api: shared.api, sockets: shared.sockets, server }));
+        }
+        catch (err) {
+            console.error('[vitek-serve] onServerStart failed:', err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    }
+    let shuttingDown = false;
+    const shutdown = async () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        if (onServerShutdown) {
+            try {
+                await Promise.resolve(onServerShutdown());
+            }
+            catch (err) {
+                console.warn('[vitek-serve] onServerShutdown error:', err instanceof Error ? err.message : String(err));
+            }
+        }
+        server.close(() => process.exit(0));
+        setTimeout(() => process.exit(0), 5000);
+    };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
     server.listen(port, host, () => {
         const base = `http://${host === '0.0.0.0' ? 'localhost' : host}:${port}`;
         console.log(`[vitek-serve] Ready at ${base}`);
     });
 }
-main().catch((err) => {
-    console.error('[vitek-serve]', err);
-    process.exit(1);
-});
+const isServeEntry = process.argv[1]?.endsWith('serve.js');
+if (typeof process.env.VITEST === 'undefined' && isServeEntry) {
+    main().catch((err) => {
+        console.error('[vitek-serve]', err);
+        process.exit(1);
+    });
+}

package/dist/cli/serve.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=serve.test.d.ts.map

package/dist/cli/serve.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.test.d.ts","sourceRoot":"","sources":["../../src/cli/serve.test.ts"],"names":[],"mappings":""}

package/dist/cli/serve.test.js

@@ -0,0 +1,108 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { parseArgs, loadProductionConfig } from './serve.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+describe('parseArgs', () => {
+    const originalEnv = { ...process.env };
+    const originalArgv = [...process.argv];
+    beforeEach(() => {
+        process.argv = ['node', 'vitek-serve'];
+        process.env = { ...originalEnv };
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+        process.argv = originalArgv;
+    });
+    it('uses default dir, port, host when no args or env', () => {
+        delete process.env.PORT;
+        delete process.env.HOST;
+        process.argv = ['node', 'vitek-serve'];
+        const result = parseArgs();
+        expect(result.dir).toBe('dist');
+        expect(result.port).toBe(3000);
+        expect(result.host).toBe('0.0.0.0');
+        expect(result.cors).toBe(false);
+        expect(result.trustProxy).toBe(false);
+    });
+    it('uses process.env.PORT when --port not passed', () => {
+        process.env.PORT = '8080';
+        delete process.env.HOST;
+        process.argv = ['node', 'vitek-serve'];
+        const result = parseArgs();
+        expect(result.port).toBe(8080);
+        expect(result.host).toBe('0.0.0.0');
+    });
+    it('uses process.env.HOST when --host not passed', () => {
+        delete process.env.PORT;
+        process.env.HOST = '127.0.0.1';
+        process.argv = ['node', 'vitek-serve'];
+        const result = parseArgs();
+        expect(result.port).toBe(3000);
+        expect(result.host).toBe('127.0.0.1');
+    });
+    it('--port overrides process.env.PORT', () => {
+        process.env.PORT = '8080';
+        process.argv = ['node', 'vitek-serve', '--port', '4000'];
+        const result = parseArgs();
+        expect(result.port).toBe(4000);
+    });
+    it('--host overrides process.env.HOST', () => {
+        process.env.HOST = '127.0.0.1';
+        process.argv = ['node', 'vitek-serve', '--host', '0.0.0.0'];
+        const result = parseArgs();
+        expect(result.host).toBe('0.0.0.0');
+    });
+    it('invalid PORT falls back to 3000', () => {
+        process.env.PORT = 'not-a-number';
+        process.argv = ['node', 'vitek-serve'];
+        const result = parseArgs();
+        expect(result.port).toBe(3000);
+    });
+    it('parses --cors and --trust-proxy', () => {
+        process.argv = ['node', 'vitek-serve', '--cors', '--trust-proxy'];
+        const result = parseArgs();
+        expect(result.cors).toBe(true);
+        expect(result.trustProxy).toBe(true);
+    });
+});
+describe('loadProductionConfig', () => {
+    it('returns empty object when vitek.config.mjs does not exist', async () => {
+        const result = await loadProductionConfig(path.join(__dirname, '..', '..', 'core'));
+        expect(result).toEqual({});
+    });
+    it('loads beforeApiRequest and onError when vitek.config.mjs exists', async () => {
+        const fixtureDir = path.join(__dirname, 'fixtures', 'serve-config');
+        const result = await loadProductionConfig(fixtureDir);
+        expect(result.beforeApiRequest).toBeDefined();
+        expect(Array.isArray(result.beforeApiRequest)).toBe(true);
+        expect(result.beforeApiRequest.length).toBe(1);
+        expect(typeof result.beforeApiRequest[0]).toBe('function');
+        expect(result.onError).toBeDefined();
+        expect(typeof result.onError).toBe('function');
+    });
+    it('loads onServerStart and onServerShutdown when vitek.config.mjs exports them', async () => {
+        const fixtureDir = path.join(__dirname, 'fixtures', 'serve-config');
+        const result = await loadProductionConfig(fixtureDir);
+        expect(result.onServerStart).toBeDefined();
+        expect(typeof result.onServerStart).toBe('function');
+        expect(result.onServerShutdown).toBeDefined();
+        expect(typeof result.onServerShutdown).toBe('function');
+    });
+    it('onServerStart receives context with api, sockets, server', async () => {
+        const fixtureDir = path.join(__dirname, 'fixtures', 'serve-config');
+        const result = await loadProductionConfig(fixtureDir);
+        const mockCtx = {
+            api: { fetch: async () => ({}) },
+            sockets: { emit: () => { } },
+            server: {},
+        };
+        delete globalThis.__vitekOnServerStartCtx;
+        delete globalThis.__vitekOnServerStartCalled;
+        result.onServerStart(mockCtx);
+        expect(globalThis.__vitekOnServerStartCalled).toBe(true);
+        expect(globalThis.__vitekOnServerStartCtx).toEqual(mockCtx);
+        delete globalThis.__vitekOnServerStartCtx;
+        delete globalThis.__vitekOnServerStartCalled;
+    });
+});

package/dist/core/asyncapi/generate.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate.test.d.ts.map

package/dist/core/asyncapi/generate.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.test.d.ts","sourceRoot":"","sources":["../../../src/core/asyncapi/generate.test.ts"],"names":[],"mappings":""}

package/dist/core/asyncapi/generate.test.js

@@ -0,0 +1,120 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { generateAsyncApiSpec, generateAsyncApiFile, } from './generate.js';
+function socket(pattern) {
+    return { pattern };
+}
+describe('generateAsyncApiSpec', () => {
+    it('returns valid AsyncAPI 2.x spec with empty sockets', () => {
+        const spec = generateAsyncApiSpec([], '/ws', {});
+        expect(spec.asyncapi).toBe('2.4.0');
+        expect(spec.info).toEqual({
+            title: 'Vitek WebSocket API',
+            version: '1.0.0',
+            description: 'WebSocket endpoints (auto-generated from socket routes)',
+        });
+        expect(spec.channels).toEqual({});
+        expect(spec.servers).toBeDefined();
+        expect(spec.servers.development).toBeDefined();
+    });
+    it('uses custom info when provided', () => {
+        const spec = generateAsyncApiSpec([], '/ws', {
+            info: {
+                title: 'My WebSocket API',
+                version: '2.0.0',
+                description: 'Custom WS API',
+            },
+        });
+        expect(spec.info).toEqual({
+            title: 'My WebSocket API',
+            version: '2.0.0',
+            description: 'Custom WS API',
+        });
+    });
+    it('uses custom serverUrl when provided', () => {
+        const spec = generateAsyncApiSpec([], '/ws', {
+            serverUrl: 'wss://api.example.com/ws',
+        });
+        const servers = spec.servers;
+        const dev = servers.development;
+        expect(dev.url).toBe('wss://api.example.com/ws');
+        expect(dev.protocol).toBe('wss');
+    });
+    it('default serverUrl uses ws protocol', () => {
+        const spec = generateAsyncApiSpec([], '/ws', {});
+        const servers = spec.servers;
+        const dev = servers.development;
+        expect(dev.url).toBe('ws://localhost:5173');
+        expect(dev.protocol).toBe('ws');
+    });
+    it('generates channel for root socket pattern', () => {
+        const sockets = [socket('')];
+        const spec = generateAsyncApiSpec(sockets, '/ws', {});
+        const channels = spec.channels;
+        expect(channels['/ws']).toBeDefined();
+        const channel = channels['/ws'];
+        expect(channel.description).toContain('Root WebSocket');
+        expect(channel.subscribe).toBeDefined();
+        expect(channel.publish).toBeDefined();
+    });
+    it('generates channel for path socket pattern', () => {
+        const sockets = [socket('notifications')];
+        const spec = generateAsyncApiSpec(sockets, '/ws', {});
+        const channels = spec.channels;
+        expect(channels['/ws/notifications']).toBeDefined();
+        const channel = channels['/ws/notifications'];
+        expect(channel.description).toContain('WebSocket');
+        expect(channel.subscribe.operationId).toContain('onMessage');
+        expect(channel.publish.operationId).toContain('send');
+    });
+    it('generates multiple channels for multiple sockets', () => {
+        const sockets = [socket('chat'), socket('notifications'), socket('')];
+        const spec = generateAsyncApiSpec(sockets, '/ws', {});
+        const channels = spec.channels;
+        expect(Object.keys(channels)).toHaveLength(3);
+        expect(channels['/ws/chat']).toBeDefined();
+        expect(channels['/ws/notifications']).toBeDefined();
+        expect(channels['/ws']).toBeDefined();
+    });
+    it('channel subscribe and publish have message payload schema', () => {
+        const sockets = [socket('events')];
+        const spec = generateAsyncApiSpec(sockets, '/ws', {});
+        const channel = spec.channels['/ws/events'];
+        const sub = channel.subscribe;
+        const subMsg = sub.message.payload;
+        expect(subMsg.type).toBe('object');
+        const pub = channel.publish;
+        const pubMsg = pub.message.payload;
+        expect(pubMsg.type).toBe('object');
+    });
+});
+describe('generateAsyncApiFile', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(process.cwd(), 'asyncapi-gen-test-'));
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+        catch {
+            //
+        }
+    });
+    it('writes valid JSON spec to file', async () => {
+        const outputPath = path.join(tmpDir, 'asyncapi.json');
+        const sockets = [socket('chat')];
+        await generateAsyncApiFile(outputPath, sockets, '/ws', {});
+        expect(fs.existsSync(outputPath)).toBe(true);
+        const content = fs.readFileSync(outputPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        expect(parsed.asyncapi).toBe('2.4.0');
+        expect(parsed.channels['/ws/chat']).toBeDefined();
+    });
+    it('creates directory if it does not exist', async () => {
+        const outputPath = path.join(tmpDir, 'nested', 'dir', 'asyncapi.json');
+        await generateAsyncApiFile(outputPath, [], '/ws', {});
+        expect(fs.existsSync(outputPath)).toBe(true);
+    });
+});

package/dist/core/context/create-context.d.ts

@@ -11,6 +11,8 @@ export interface VitekContext {
     params: Record<string, string>;
     headers: Record<string, string>;
     body?: any;
+    /** When trustProxy is true, client IP from X-Forwarded-For or socket.remoteAddress. */
+    clientIp?: string;
     /** When the app runs with shared context (dev, preview, serve), use to broadcast to WebSocket clients. */
     sockets?: SocketEmitter;
 }

package/dist/core/context/create-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-context.d.ts","sourceRoot":"","sources":["../../../src/core/context/create-context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE5D,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IACzC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,0GAA0G;IAC1G,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,aAAa,CAWlE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,YAAY,EACrB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACnC,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAM,GAC5C,YAAY,CAYd"}
+{"version":3,"file":"create-context.d.ts","sourceRoot":"","sources":["../../../src/core/context/create-context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE5D,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IACzC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,uFAAuF;IACvF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0GAA0G;IAC1G,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,aAAa,CAWlE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,YAAY,EACrB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACnC,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAM,GAC5C,YAAY,CAYd"}

package/dist/core/file-system/watch-api-dir.d.ts

@@ -4,6 +4,9 @@
  */
 export type FileChangeEvent = 'add' | 'change' | 'unlink';
 export type FileChangeCallback = (event: FileChangeEvent, filePath: string) => void;
+export interface WatchApiDirectoryOptions {
+    debounceMs?: number;
+}
 /**
  * Interface for watcher (allows different implementations)
  */
@@ -14,5 +17,5 @@ export interface ApiWatcher {
  * Creates a watcher for the API directory using Node.js fs.watch
  * Returns a function to stop watching
  */
-export declare function watchApiDirectory(apiDir: string, callback: FileChangeCallback): ApiWatcher;
+export declare function watchApiDirectory(apiDir: string, callback: FileChangeCallback, options?: WatchApiDirectoryOptions): ApiWatcher;
 //# sourceMappingURL=watch-api-dir.d.ts.map

package/dist/core/file-system/watch-api-dir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch-api-dir.d.ts","sourceRoot":"","sources":["../../../src/core/file-system/watch-api-dir.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAC1D,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;AAEpF;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,kBAAkB,GAC3B,UAAU,CAiCZ"}
+{"version":3,"file":"watch-api-dir.d.ts","sourceRoot":"","sources":["../../../src/core/file-system/watch-api-dir.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAC1D,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;AAEpF,MAAM,WAAW,wBAAwB;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,GAAE,wBAA6B,GACrC,UAAU,CA2DZ"}