comisai 1.0.4

package/node_modules/@comis/gateway/dist/acp/acp-server.d.ts

@@ -0,0 +1,74 @@
+/**
+ * ACP Agent Server — Agent Communication Protocol implementation for IDE integration.
+ *
+ * Implements the ACP Agent interface from @agentclientprotocol/sdk, enabling
+ * VS Code, JetBrains, Zed, and other ACP-compatible IDEs to connect to Comis
+ * as an AI agent through the standardized Agent Communication Protocol.
+ *
+ * The ACP server runs as a standalone entry point that the IDE spawns as a subprocess,
+ * communicating via ndJson over stdin/stdout.
+ *
+ * IMPORTANT: All logging MUST go to stderr (not stdout) to avoid corrupting the
+ * ndJson protocol. The deps.logger is expected to be configured for stderr output
+ * when running in ACP mode.
+ */
+import { type Agent } from "@agentclientprotocol/sdk";
+import { type AcpSessionMap } from "./acp-session-map.js";
+/**
+ * Dependency interface for the ACP server.
+ * Uses function callbacks to keep the gateway decoupled from agent internals.
+ */
+export interface AcpServerDeps {
+    /** Execute an agent turn and return the response. */
+    executeAgent: (params: {
+        message: string;
+        sessionKey: {
+            userId: string;
+            channelId: string;
+            peerId: string;
+        };
+        onDelta?: (delta: string) => void;
+    }) => Promise<{
+        response: string;
+        tokensUsed: {
+            input: number;
+            output: number;
+            total: number;
+        };
+        finishReason: string;
+    }>;
+    /** Logger — MUST write to stderr when running in ACP mode. */
+    logger: {
+        info(...args: unknown[]): void;
+        error(...args: unknown[]): void;
+        warn(...args: unknown[]): void;
+    };
+    /** Agent version string. Defaults to "0.0.1". */
+    version?: string;
+}
+/**
+ * Create an ACP Agent implementation that delegates to Comis's agent executor.
+ *
+ * The returned object satisfies the ACP Agent interface with:
+ * - initialize: Returns protocol version, agent info, and capabilities
+ * - newSession: Creates an Comis session mapped to the ACP session
+ * - prompt: Extracts user message and delegates to executeAgent
+ * - authenticate: No-op for local agent
+ * - cancel: Removes session from map (execution abort is a future enhancement)
+ *
+ * @param deps - Server dependencies (executeAgent, logger, version)
+ * @returns Object exposing the ACP Agent interface and the internal session map
+ */
+export declare function createAcpAgent(deps: AcpServerDeps): {
+    agent: Agent;
+    sessionMap: AcpSessionMap;
+};
+/**
+ * Start the ACP server with stdio transport.
+ *
+ * Creates an ndJson stream over stdin/stdout and establishes an AgentSideConnection.
+ * The server runs until the IDE closes the connection (stdin ends).
+ *
+ * @param deps - Server dependencies (executeAgent, logger, version)
+ */
+export declare function startAcpServer(deps: AcpServerDeps): Promise<void>;

package/node_modules/@comis/gateway/dist/acp/acp-server.js

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * ACP Agent Server — Agent Communication Protocol implementation for IDE integration.
+ *
+ * Implements the ACP Agent interface from @agentclientprotocol/sdk, enabling
+ * VS Code, JetBrains, Zed, and other ACP-compatible IDEs to connect to Comis
+ * as an AI agent through the standardized Agent Communication Protocol.
+ *
+ * The ACP server runs as a standalone entry point that the IDE spawns as a subprocess,
+ * communicating via ndJson over stdin/stdout.
+ *
+ * IMPORTANT: All logging MUST go to stderr (not stdout) to avoid corrupting the
+ * ndJson protocol. The deps.logger is expected to be configured for stderr output
+ * when running in ACP mode.
+ */
+import { AgentSideConnection, ndJsonStream, } from "@agentclientprotocol/sdk";
+import { createAcpSessionMap } from "./acp-session-map.js";
+/**
+ * Extract user text from ACP prompt content blocks.
+ *
+ * Collects all text-type content blocks from the prompt and joins them.
+ * Non-text blocks (images, audio, resources) are skipped.
+ */
+function extractUserMessage(prompt) {
+    const textParts = [];
+    for (const block of prompt) {
+        if ("type" in block && block.type === "text" && "text" in block) {
+            textParts.push(block.text);
+        }
+    }
+    return textParts.join("\n");
+}
+/**
+ * Create an ACP Agent implementation that delegates to Comis's agent executor.
+ *
+ * The returned object satisfies the ACP Agent interface with:
+ * - initialize: Returns protocol version, agent info, and capabilities
+ * - newSession: Creates an Comis session mapped to the ACP session
+ * - prompt: Extracts user message and delegates to executeAgent
+ * - authenticate: No-op for local agent
+ * - cancel: Removes session from map (execution abort is a future enhancement)
+ *
+ * @param deps - Server dependencies (executeAgent, logger, version)
+ * @returns Object exposing the ACP Agent interface and the internal session map
+ */
+export function createAcpAgent(deps) {
+    const sessionMap = createAcpSessionMap();
+    const version = deps.version ?? "0.0.1";
+    const agent = {
+        async initialize(params) {
+            deps.logger.info({ protocolVersion: params.protocolVersion }, "ACP initialize request received");
+            return {
+                protocolVersion: params.protocolVersion,
+                agentInfo: {
+                    name: "comis",
+                    title: "Comis",
+                    version,
+                },
+                agentCapabilities: {},
+            };
+        },
+        async newSession(_params) {
+            const sessionId = crypto.randomUUID();
+            sessionMap.create(sessionId);
+            deps.logger.info({ sessionId }, "ACP session created");
+            return { sessionId };
+        },
+        async prompt(params) {
+            const sessionKey = sessionMap.get(params.sessionId);
+            if (!sessionKey) {
+                deps.logger.error({ sessionId: params.sessionId, hint: "Ensure newSession was called before prompt, or session was not cancelled", errorKind: "validation" }, "ACP prompt for unknown session");
+                throw new Error(`Unknown ACP session: ${params.sessionId}`);
+            }
+            const message = extractUserMessage(params.prompt);
+            try {
+                await deps.executeAgent({ message, sessionKey });
+                return { stopReason: "end_turn" };
+            }
+            catch (err) {
+                deps.logger.error({ err, sessionId: params.sessionId, hint: "Check agent executor logs or LLM provider connectivity", errorKind: "dependency" }, "ACP prompt execution failed");
+                return { stopReason: "end_turn" };
+            }
+        },
+        async authenticate(_params) {
+            // No-op for local agent — no authentication required
+        },
+        async cancel(params) {
+            deps.logger.info({ sessionId: params.sessionId }, "ACP cancel request received");
+            sessionMap.remove(params.sessionId);
+            // Actual execution abort is a future enhancement
+        },
+    };
+    return { agent, sessionMap };
+}
+/**
+ * Start the ACP server with stdio transport.
+ *
+ * Creates an ndJson stream over stdin/stdout and establishes an AgentSideConnection.
+ * The server runs until the IDE closes the connection (stdin ends).
+ *
+ * @param deps - Server dependencies (executeAgent, logger, version)
+ */
+export async function startAcpServer(deps) {
+    // Wrap stdout as a WritableStream<Uint8Array>
+    const writableStdout = new WritableStream({
+        write(chunk) {
+            process.stdout.write(chunk);
+        },
+    });
+    // Wrap stdin as a ReadableStream<Uint8Array>
+    // Node.js >= 20 supports ReadableStream.from() on async iterables
+    const fromStream = ReadableStream.from;
+    const readableStdin = fromStream(process.stdin);
+    // Create ndJson stream for ACP communication
+    const stream = ndJsonStream(writableStdout, readableStdin);
+    // Create the agent-side connection
+    const connection = new AgentSideConnection(() => createAcpAgent(deps).agent, stream);
+    deps.logger.info("ACP server started, awaiting IDE connection on stdio");
+    // Wait for the connection to close (stdin ends or IDE disconnects)
+    await connection.closed;
+    deps.logger.info("ACP server connection closed, shutting down");
+}

package/node_modules/@comis/gateway/dist/acp/acp-session-map.d.ts

@@ -0,0 +1,39 @@
+/**
+ * ACP Session Map — maps ACP session IDs to Comis SessionKey triples.
+ *
+ * Each ACP session (created by an IDE client) is assigned an Comis-compatible
+ * session key with channelId "acp", userId "ide-user", and peerId set to the
+ * ACP session ID. This follows the channel adapter pattern where each protocol
+ * gets a dedicated channelId.
+ */
+/**
+ * Minimal SessionKey triple used for ACP session mapping.
+ * Matches the subset of core's SessionKey needed for agent execution.
+ */
+export interface AcpSessionKey {
+    readonly userId: string;
+    readonly channelId: string;
+    readonly peerId: string;
+}
+/**
+ * Maps ACP session IDs to Comis SessionKey triples.
+ */
+export interface AcpSessionMap {
+    /** Create and store a SessionKey for the given ACP session ID. */
+    create(acpSessionId: string): AcpSessionKey;
+    /** Retrieve the SessionKey for the given ACP session ID, or undefined if not found. */
+    get(acpSessionId: string): AcpSessionKey | undefined;
+    /** Remove the mapping for the given ACP session ID. Returns true if it existed. */
+    remove(acpSessionId: string): boolean;
+    /** Return a snapshot of all active session mappings. */
+    getAll(): ReadonlyMap<string, AcpSessionKey>;
+    /** Remove all session mappings. */
+    clear(): void;
+}
+/**
+ * Create an ACP session map that tracks ACP-to-Comis session mappings.
+ *
+ * Uses channelId "acp", userId "ide-user", and peerId = acpSessionId,
+ * following the convention for IDE integration sessions.
+ */
+export declare function createAcpSessionMap(maxSessions?: number): AcpSessionMap;

package/node_modules/@comis/gateway/dist/acp/acp-session-map.js

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * ACP Session Map — maps ACP session IDs to Comis SessionKey triples.
+ *
+ * Each ACP session (created by an IDE client) is assigned an Comis-compatible
+ * session key with channelId "acp", userId "ide-user", and peerId set to the
+ * ACP session ID. This follows the channel adapter pattern where each protocol
+ * gets a dedicated channelId.
+ */
+/**
+ * Create an ACP session map that tracks ACP-to-Comis session mappings.
+ *
+ * Uses channelId "acp", userId "ide-user", and peerId = acpSessionId,
+ * following the convention for IDE integration sessions.
+ */
+export function createAcpSessionMap(maxSessions = 1000) {
+    const sessions = new Map();
+    return {
+        create(acpSessionId) {
+            // Evict oldest session when at capacity
+            if (sessions.size >= maxSessions) {
+                // Map iteration order is insertion order -- first key is oldest
+                const oldestKey = sessions.keys().next().value;
+                if (oldestKey !== undefined) {
+                    sessions.delete(oldestKey);
+                }
+            }
+            const sessionKey = {
+                userId: "ide-user",
+                channelId: "acp",
+                peerId: acpSessionId,
+            };
+            sessions.set(acpSessionId, sessionKey);
+            return sessionKey;
+        },
+        get(acpSessionId) {
+            return sessions.get(acpSessionId);
+        },
+        remove(acpSessionId) {
+            return sessions.delete(acpSessionId);
+        },
+        getAll() {
+            // Return a snapshot to prevent external mutation (per 63-06 decision)
+            return new Map(sessions);
+        },
+        clear() {
+            sessions.clear();
+        },
+    };
+}

package/node_modules/@comis/gateway/dist/acp/index.d.ts

@@ -0,0 +1,4 @@
+export { createAcpAgent, startAcpServer } from "./acp-server.js";
+export type { AcpServerDeps } from "./acp-server.js";
+export { createAcpSessionMap } from "./acp-session-map.js";
+export type { AcpSessionMap, AcpSessionKey } from "./acp-session-map.js";

package/node_modules/@comis/gateway/dist/acp/index.js

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
+// ACP (Agent Communication Protocol) — IDE integration via ndJson/stdio
+export { createAcpAgent, startAcpServer } from "./acp-server.js";
+export { createAcpSessionMap } from "./acp-session-map.js";

package/node_modules/@comis/gateway/dist/auth/mtls-verifier.d.ts

@@ -0,0 +1,24 @@
+import type { Result } from "@comis/shared";
+import type { TLSSocket } from "node:tls";
+/**
+ * TLS certificate paths for mTLS validation.
+ */
+export interface CertPaths {
+    readonly certPath: string;
+    readonly keyPath: string;
+    readonly caPath: string;
+}
+/**
+ * Validate that certificate files exist, are readable PEM, and are not expired.
+ *
+ * Called at startup to fail fast if TLS config is misconfigured.
+ * Returns Result<void, Error> — no silent failures.
+ */
+export declare function validateCertificates(paths: CertPaths): Result<void, Error>;
+/**
+ * Extract the Common Name (CN) from a TLS client certificate.
+ *
+ * Returns null if the socket has no authorized client certificate
+ * or the certificate has no subject CN.
+ */
+export declare function extractClientCN(socket: TLSSocket): string | null;

package/node_modules/@comis/gateway/dist/auth/mtls-verifier.js

@@ -0,0 +1,70 @@
+import { ok, err } from "@comis/shared";
+import { X509Certificate } from "node:crypto";
+import { readFileSync } from "node:fs";
+/**
+ * Validate that certificate files exist, are readable PEM, and are not expired.
+ *
+ * Called at startup to fail fast if TLS config is misconfigured.
+ * Returns Result<void, Error> — no silent failures.
+ */
+export function validateCertificates(paths) {
+    const files = [
+        { label: "server certificate", path: paths.certPath },
+        { label: "server key", path: paths.keyPath },
+        { label: "CA certificate", path: paths.caPath },
+    ];
+    for (const file of files) {
+        let content;
+        try {
+            content = readFileSync(file.path, "utf-8");
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return err(new Error(`Failed to read ${file.label} at ${file.path}: ${msg}`));
+        }
+        if (!content.includes("-----BEGIN ")) {
+            return err(new Error(`${file.label} at ${file.path} does not appear to be PEM format`));
+        }
+    }
+    // Validate cert and CA are not expired
+    const certFiles = [
+        { label: "server certificate", path: paths.certPath },
+        { label: "CA certificate", path: paths.caPath },
+    ];
+    for (const file of certFiles) {
+        try {
+            const pem = readFileSync(file.path, "utf-8");
+            const cert = new X509Certificate(pem);
+            const notAfter = new Date(cert.validTo);
+            if (notAfter.getTime() < Date.now()) {
+                return err(new Error(`${file.label} at ${file.path} expired on ${cert.validTo}`));
+            }
+        }
+        catch (e) {
+            // If it's our own Error from above, re-throw; otherwise wrap
+            if (e instanceof Error && e.message.startsWith("Failed to read")) {
+                return err(e);
+            }
+            const msg = e instanceof Error ? e.message : String(e);
+            return err(new Error(`Failed to parse ${file.label} at ${file.path}: ${msg}`));
+        }
+    }
+    return ok(undefined);
+}
+/**
+ * Extract the Common Name (CN) from a TLS client certificate.
+ *
+ * Returns null if the socket has no authorized client certificate
+ * or the certificate has no subject CN.
+ */
+export function extractClientCN(socket) {
+    if (!socket.authorized) {
+        return null;
+    }
+    const cert = socket.getPeerCertificate();
+    if (!cert || !cert.subject) {
+        return null;
+    }
+    const cn = cert.subject.CN ?? null;
+    return Array.isArray(cn) ? cn[0] ?? null : cn;
+}

package/node_modules/@comis/gateway/dist/auth/token-auth.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Authenticated client identity resolved from a bearer token.
+ */
+export interface TokenClient {
+    /** Unique identifier for this client / API key */
+    readonly id: string;
+    /** Allowed scopes for this client (e.g., ["rpc", "ws", "admin"]) */
+    readonly scopes: readonly string[];
+}
+/**
+ * Token verification store — maps bearer tokens to client identities.
+ */
+export interface TokenStore {
+    /** Verify a bearer token and return the associated client, or null if invalid. */
+    verify(token: string): TokenClient | null;
+}
+/**
+ * Token entry used to seed the store (matches GatewayToken from config).
+ */
+export interface TokenEntry {
+    readonly id: string;
+    readonly secret: string;
+    readonly scopes: readonly string[];
+}
+/**
+ * Create a TokenStore from a list of token entries.
+ *
+ * Uses crypto.timingSafeEqual for constant-time comparison to prevent
+ * timing-based token enumeration attacks.
+ */
+export declare function createTokenStore(tokens: readonly TokenEntry[]): TokenStore;
+/**
+ * Check whether a set of scopes satisfies a required scope.
+ *
+ * The wildcard scope "*" grants access to all scopes.
+ *
+ * @param scopes - The client's granted scopes
+ * @param required - The scope required for the operation
+ * @returns true if access is granted
+ */
+export declare function checkScope(scopes: readonly string[], required: string): boolean;
+/**
+ * Result of token authentication middleware — set on the Hono context.
+ */
+export interface TokenAuthContext {
+    readonly clientId: string;
+    readonly scopes: readonly string[];
+}
+/**
+ * Extract the bearer token from an Authorization header value.
+ *
+ * Returns null if the header is missing or not in "Bearer <token>" format.
+ */
+export declare function extractBearerToken(authHeader: string | undefined | null): string | null;

package/node_modules/@comis/gateway/dist/auth/token-auth.js

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+import { timingSafeEqual } from "node:crypto";
+/**
+ * Create a TokenStore from a list of token entries.
+ *
+ * Uses crypto.timingSafeEqual for constant-time comparison to prevent
+ * timing-based token enumeration attacks.
+ */
+export function createTokenStore(tokens) {
+    // Store entries keyed by secret length for efficient lookup grouping.
+    // We compare ALL entries to maintain constant-time behavior.
+    const entries = tokens.map((t) => ({
+        id: t.id,
+        secretBuf: Buffer.from(t.secret, "utf-8"),
+        scopes: t.scopes,
+    }));
+    return {
+        verify(token) {
+            const tokenBuf = Buffer.from(token, "utf-8");
+            for (const entry of entries) {
+                // timingSafeEqual requires equal-length buffers.
+                // If lengths differ, this token cannot match this entry.
+                if (tokenBuf.length !== entry.secretBuf.length) {
+                    continue;
+                }
+                if (timingSafeEqual(tokenBuf, entry.secretBuf)) {
+                    return { id: entry.id, scopes: entry.scopes };
+                }
+            }
+            return null;
+        },
+    };
+}
+/**
+ * Check whether a set of scopes satisfies a required scope.
+ *
+ * The wildcard scope "*" grants access to all scopes.
+ *
+ * @param scopes - The client's granted scopes
+ * @param required - The scope required for the operation
+ * @returns true if access is granted
+ */
+export function checkScope(scopes, required) {
+    return scopes.includes("*") || scopes.includes(required);
+}
+/**
+ * Extract the bearer token from an Authorization header value.
+ *
+ * Returns null if the header is missing or not in "Bearer <token>" format.
+ */
+export function extractBearerToken(authHeader) {
+    if (!authHeader)
+        return null;
+    const match = /^Bearer\s+([A-Za-z0-9._~+/-]+=*)$/i.exec(authHeader);
+    return match ? match[1] : null;
+}

package/node_modules/@comis/gateway/dist/discovery/index.d.ts

@@ -0,0 +1 @@
+export { createMdnsAdvertiser, type MdnsAdvertiserDeps, type MdnsAdvertiserHandle, } from "./mdns-advertiser.js";

package/node_modules/@comis/gateway/dist/discovery/index.js

@@ -0,0 +1,3 @@
+// SPDX-License-Identifier: Apache-2.0
+// mDNS/Bonjour service discovery
+export { createMdnsAdvertiser, } from "./mdns-advertiser.js";

package/node_modules/@comis/gateway/dist/discovery/mdns-advertiser.d.ts

@@ -0,0 +1,45 @@
+/**
+ * mDNS/Bonjour service advertiser for gateway discovery.
+ *
+ * Uses @homebridge/ciao to advertise the gateway on the local network
+ * via mDNS (RFC 6762/6763). Clients on the LAN can automatically
+ * discover the gateway for zero-config setup.
+ */
+/**
+ * Dependencies for the mDNS advertiser.
+ */
+export interface MdnsAdvertiserDeps {
+    /** Gateway port to advertise */
+    port: number;
+    /** Service name (default: "Comis Gateway") */
+    name?: string;
+    /** Version string for TXT record (default: "0.0.1") */
+    version?: string;
+    /** Logger for info/error messages */
+    logger: {
+        info(...args: unknown[]): void;
+        error(...args: unknown[]): void;
+    };
+}
+/**
+ * Handle returned by createMdnsAdvertiser for lifecycle management.
+ */
+export interface MdnsAdvertiserHandle {
+    /** Start mDNS advertisement */
+    advertise(): Promise<void>;
+    /** Stop advertisement and clean up responder */
+    stop(): Promise<void>;
+    /** Returns whether the service is currently advertising */
+    isAdvertising(): boolean;
+}
+/**
+ * Create an mDNS/Bonjour service advertiser.
+ *
+ * Uses ciao's getResponder() singleton to create and manage a service
+ * that advertises the gateway on the local network. The service includes
+ * TXT records with version, API path, and capability information.
+ *
+ * Shutdown is best-effort: errors during stop are caught and logged
+ * but not re-thrown, following the 61-02 pattern for cleanup operations.
+ */
+export declare function createMdnsAdvertiser(deps: MdnsAdvertiserDeps): MdnsAdvertiserHandle;

package/node_modules/@comis/gateway/dist/discovery/mdns-advertiser.js

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * mDNS/Bonjour service advertiser for gateway discovery.
+ *
+ * Uses @homebridge/ciao to advertise the gateway on the local network
+ * via mDNS (RFC 6762/6763). Clients on the LAN can automatically
+ * discover the gateway for zero-config setup.
+ */
+import ciao from "@homebridge/ciao";
+/**
+ * Create an mDNS/Bonjour service advertiser.
+ *
+ * Uses ciao's getResponder() singleton to create and manage a service
+ * that advertises the gateway on the local network. The service includes
+ * TXT records with version, API path, and capability information.
+ *
+ * Shutdown is best-effort: errors during stop are caught and logged
+ * but not re-thrown, following the 61-02 pattern for cleanup operations.
+ */
+export function createMdnsAdvertiser(deps) {
+    const { port, logger } = deps;
+    const name = deps.name ?? "Comis Gateway";
+    const version = deps.version ?? "0.0.1";
+    const responder = ciao.getResponder();
+    const service = responder.createService({
+        name,
+        type: "http",
+        port,
+        txt: {
+            version,
+            path: "/v1",
+            openai_compat: "true",
+            acp: "stdio",
+        },
+    });
+    let advertising = false;
+    return {
+        async advertise() {
+            await service.advertise();
+            advertising = true;
+            logger.info({ name, port, version }, "mDNS service advertised");
+        },
+        async stop() {
+            if (!advertising) {
+                return;
+            }
+            try {
+                await service.end();
+                await responder.shutdown();
+                advertising = false;
+                logger.info({ name }, "mDNS service stopped");
+            }
+            catch (error) {
+                // Shutdown must be best-effort (per 61-02 pattern)
+                advertising = false;
+                logger.error({ err: error, hint: "mDNS shutdown is best-effort; the service may already be stopped", errorKind: "network" }, "Failed to stop mDNS service cleanly");
+            }
+        },
+        isAdvertising() {
+            return advertising;
+        },
+    };
+}

package/node_modules/@comis/gateway/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { createGatewayServer } from "./server/hono-server.js";
+export type { GatewayServerHandle } from "./server/hono-server.js";
+export { createTokenStore, extractBearerToken, checkScope } from "./auth/token-auth.js";
+export { createRateLimiter } from "./rate-limit/rate-limiter.js";
+export { createDynamicMethodRouter } from "./rpc/method-router.js";
+export type { DynamicMethodRouter } from "./rpc/method-router.js";
+export { createRpcAdapters } from "./rpc/rpc-adapters.js";
+export type { RpcAdapterDeps } from "./rpc/rpc-adapters.js";
+export { WsConnectionManager } from "./rpc/ws-handler.js";
+export { createMappedWebhookEndpoint } from "./webhook/webhook-endpoint.js";
+export { getPresetMappings } from "./webhook/webhook-presets.js";
+export { createMediaRoutes } from "./web/index.js";
+export { createOpenaiCompletionsRoute } from "./openai/index.js";
+export { createOpenaiModelsRoute } from "./openai/index.js";
+export { createOpenaiEmbeddingsRoute } from "./openai/index.js";
+export { createResponsesRoute } from "./responses/index.js";
+export { createAcpAgent } from "./acp/index.js";
+export type { AcpServerDeps } from "./acp/index.js";
+export { createMdnsAdvertiser } from "./discovery/index.js";

package/node_modules/@comis/gateway/dist/index.js

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0
+// @comis/gateway -- HTTPS gateway with mTLS, JSON-RPC, WebSocket, and webhook support
+// Public API -- all exports have verified external consumers.
+// Server
+export { createGatewayServer } from "./server/hono-server.js";
+// Auth -- Token
+export { createTokenStore, extractBearerToken, checkScope } from "./auth/token-auth.js";
+// Rate limiting
+export { createRateLimiter } from "./rate-limit/rate-limiter.js";
+// RPC -- method router
+export { createDynamicMethodRouter } from "./rpc/method-router.js";
+// RPC -- adapters
+export { createRpcAdapters } from "./rpc/rpc-adapters.js";
+// RPC -- WebSocket
+export { WsConnectionManager } from "./rpc/ws-handler.js";
+// Webhook
+export { createMappedWebhookEndpoint } from "./webhook/webhook-endpoint.js";
+export { getPresetMappings } from "./webhook/webhook-presets.js";
+// Web -- media routes
+export { createMediaRoutes } from "./web/index.js";
+// OpenAI compatibility endpoints
+export { createOpenaiCompletionsRoute } from "./openai/index.js";
+export { createOpenaiModelsRoute } from "./openai/index.js";
+export { createOpenaiEmbeddingsRoute } from "./openai/index.js";
+// OpenResponses endpoint
+export { createResponsesRoute } from "./responses/index.js";
+// ACP server for IDE integration
+export { createAcpAgent } from "./acp/index.js";
+// mDNS/Bonjour service discovery
+export { createMdnsAdvertiser } from "./discovery/index.js";