@lovrozagar/honey 0.6.5 → 0.7.0

package/dist/client-go/ws.go

@@ -0,0 +1,128 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"sync"
+
+	"nhooyr.io/websocket"
+)
+
+// WSStatusNormalClosure is the normal close code (1000).
+const WSStatusNormalClosure = websocket.StatusNormalClosure
+
+// WSStatusGoingAway is the going away close code (1001).
+const WSStatusGoingAway = websocket.StatusGoingAway
+
+// WSStatusProtocolError is the protocol error close code (1002).
+const WSStatusProtocolError = websocket.StatusProtocolError
+
+// defaultWSReadLimit replaces nhooyr's 32 KiB default, which closes the
+// connection on any larger frame.
+const defaultWSReadLimit = 16 << 20
+
+// TypedWebSocket wraps a nhooyr.io/websocket connection with an event fanout
+// system that mirrors the TS client's .on() escape hatch.
+type TypedWebSocket struct {
+	conn     *websocket.Conn
+	mu       sync.Mutex
+	handlers map[string][]func(data []byte)
+	closed   bool
+}
+
+// newTypedWebSocket constructs a TypedWebSocket from an already-dialled conn.
+func newTypedWebSocket(conn *websocket.Conn) *TypedWebSocket {
+	conn.SetReadLimit(defaultWSReadLimit)
+	return &TypedWebSocket{
+		conn:     conn,
+		handlers: make(map[string][]func(data []byte)),
+	}
+}
+
+// SetReadLimit sets the largest inbound message, in bytes (default 16 MiB).
+func (w *TypedWebSocket) SetReadLimit(n int64) {
+	w.conn.SetReadLimit(n)
+}
+
+// Send serialises data to JSON when it is a struct or map, and passes []byte
+// (binary frame) and string (text frame) through as-is.
+func (w *TypedWebSocket) Send(ctx context.Context, data interface{}) error {
+	switch v := data.(type) {
+	case []byte:
+		return w.conn.Write(ctx, websocket.MessageBinary, v)
+	case string:
+		return w.conn.Write(ctx, websocket.MessageText, []byte(v))
+	default:
+		encoded, err := json.Marshal(v)
+		if err != nil {
+			return err
+		}
+		return w.conn.Write(ctx, websocket.MessageText, encoded)
+	}
+}
+
+// Close sends a WebSocket close frame with the given status code and reason.
+// A reason over 123 bytes is truncated to fit the frame.
+func (w *TypedWebSocket) Close(code websocket.StatusCode, reason string) error {
+	if len(reason) > 123 {
+		reason = reason[:123]
+	}
+	err := w.conn.Close(code, reason)
+	w.fireClose(int(code), reason)
+	return err
+}
+
+// Read reads the next message from the connection. On a close frame it fires
+// "close" handlers (data is the close reason); on any other failure it fires
+// "error" handlers (data is the error text).
+func (w *TypedWebSocket) Read(ctx context.Context) ([]byte, error) {
+	_, msg, err := w.conn.Read(ctx)
+	if err != nil {
+		var ce websocket.CloseError
+		if errors.As(err, &ce) {
+			w.fireClose(int(ce.Code), ce.Reason)
+		} else {
+			w.fanout("error", []byte(err.Error()))
+		}
+		return nil, err
+	}
+	w.fanout("message", msg)
+	return msg, nil
+}
+
+// On registers an event handler. Supported events: "message", "close", "error".
+// The handler receives the raw message bytes; callers unmarshal as needed.
+// This is an escape hatch — prefer ranging over Read for typed message dispatch.
+func (w *TypedWebSocket) On(event string, handler func(data []byte)) {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	w.handlers[event] = append(w.handlers[event], handler)
+}
+
+func (w *TypedWebSocket) fireClose(code int, reason string) {
+	w.mu.Lock()
+	if w.closed {
+		w.mu.Unlock()
+		return
+	}
+	w.closed = true
+	w.mu.Unlock()
+	_ = code
+	w.fanout("close", []byte(reason))
+}
+
+func (w *TypedWebSocket) fanout(event string, data []byte) {
+	w.mu.Lock()
+	handlers := append([]func([]byte){}, w.handlers[event]...)
+	w.mu.Unlock()
+	for _, h := range handlers {
+		h(data)
+	}
+}
+
+// DialOptions exposes nhooyr.io/websocket DialOptions for consumer configuration.
+// Set Subprotocols here before Dial.
+type DialOptions = websocket.DialOptions

package/dist/client-info.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Who sent a request, and over what, as the core sees it without `app.trustProxy()`: the peer
+ * the runtime reports is the client, and forwarding headers are client-controlled text. Trusting
+ * reverse proxies (hop counts, CIDR lists) lives in `trust.ts`, which `trustProxy()` loads.
+ */
+export type ClientInfo = {
+    /** Canonical client address, or `null` when it is unknown or a trusted header holds garbage. */
+    ip: string | null;
+    /** Host the client asked for (`host[:port]`), or `null`. */
+    host: string | null;
+    protocol: "http" | "https";
+};
+/**
+ * The app's compiled `trustProxy()` setting. Anything but `off` carries its own resolver, so
+ * the core never imports the hop and range logic.
+ */
+export type TrustSetting = {
+    readonly kind: "off";
+} | {
+    readonly kind: "hops" | "ranges";
+    readonly resolve: (req: Request, peer: string | null) => ClientInfo;
+};
+export declare const TRUST_OFF: TrustSetting;
+/** `host[:port]` as RFC 9110 allows it in `Host`; nothing that could change a URL's meaning. */
+export declare function isValidHost(host: string): boolean;
+/**
+ * Bun before 1.4 builds `request.url` by concatenating `Host` and the request target, so a
+ * `Host: x/admin?` picks the routed path. Later versions hand over the target alone.
+ */
+export declare const BUN_URL_FROM_HOST: boolean;
+/** `false` when the request carries a `Host` header that is not `host[:port]`. */
+export declare function hasValidHost(req: Request): boolean;
+/** The client as the connection shows it: the peer, the URL's host, the transport's scheme. */
+export declare function directClientInfo(req: Request, peer: string | null): ClientInfo;
+export declare function resolveClient(trust: TrustSetting, req: Request, peer: string | null): ClientInfo;
+//# sourceMappingURL=client-info.d.ts.map

package/dist/client-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-info.d.ts","sourceRoot":"","sources":["../src/client-info.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG;IACxB,gGAAgG;IAChG,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IACjB,4DAA4D;IAC5D,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAA;CAC1B,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,GACrB;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;CAAE,GACxB;IACA,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;IAChC,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,KAAK,UAAU,CAAA;CAClE,CAAA;AAEJ,eAAO,MAAM,SAAS,EAAE,YAA6C,CAAA;AAIrE,gGAAgG;AAChG,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQjD;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,OAK5B,CAAA;AAEJ,kFAAkF;AAClF,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAGlD;AAWD,+FAA+F;AAC/F,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,UAAU,CAM9E;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,UAAU,CAEhG"}

package/dist/client-info.js

@@ -0,0 +1,53 @@
+import { canonicalIp } from "./ip.js";
+export const TRUST_OFF = Object.freeze({ kind: "off" });
+const HOST = /^(?:\[[0-9A-Fa-f:.]+\]|[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?\.?)(?::\d{1,5})?$/;
+/** `host[:port]` as RFC 9110 allows it in `Host`; nothing that could change a URL's meaning. */
+export function isValidHost(host) {
+    if (!HOST.test(host))
+        return false;
+    const colon = host.lastIndexOf(":");
+    if (colon !== -1 && host.lastIndexOf("]") < colon) {
+        const port = Number(host.slice(colon + 1));
+        if (port > 65535)
+            return false;
+    }
+    return true;
+}
+/**
+ * Bun before 1.4 builds `request.url` by concatenating `Host` and the request target, so a
+ * `Host: x/admin?` picks the routed path. Later versions hand over the target alone.
+ */
+export const BUN_URL_FROM_HOST = (() => {
+    const version = globalThis.Bun?.version;
+    if (version === undefined)
+        return false;
+    const [major = 0, minor = 0] = version.split(".").map(Number);
+    return major < 1 || (major === 1 && minor < 4);
+})();
+/** `false` when the request carries a `Host` header that is not `host[:port]`. */
+export function hasValidHost(req) {
+    const host = req.headers.get("host");
+    return host === null || isValidHost(host);
+}
+function hostOfUrl(url) {
+    const start = url.indexOf("//");
+    if (start === -1)
+        return null;
+    let end = url.indexOf("/", start + 2);
+    if (end === -1)
+        end = url.length;
+    const host = url.slice(start + 2, end);
+    return host === "" ? null : host;
+}
+/** The client as the connection shows it: the peer, the URL's host, the transport's scheme. */
+export function directClientInfo(req, peer) {
+    return {
+        host: hostOfUrl(req.url),
+        ip: peer === null ? null : canonicalIp(peer),
+        protocol: req.url.startsWith("https:") ? "https" : "http",
+    };
+}
+export function resolveClient(trust, req, peer) {
+    return trust.kind === "off" ? directClientInfo(req, peer) : trust.resolve(req, peer);
+}
+//# sourceMappingURL=client-info.js.map

package/dist/client-info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-info.js","sourceRoot":"","sources":["../src/client-info.ts"],"names":[],"mappings":"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"}

package/dist/client-mcp/README.md

@@ -0,0 +1,10 @@
+# client-mcp/
+
+Static MCP runtime templates. Files `server.ts` + `types.ts` are copied
+verbatim into emitted `@{project}/mcp-server` packages by
+`codegen-mcp.ts` at codegen time via `readFileSync(new URL(..., import.meta.url))`.
+
+Changes here propagate to every emitted MCP server on next regen.
+
+Do not import from this directory in honey/core runtime code — it only
+exists as a template source for the emitter.

package/dist/client-mcp/server.ts

@@ -0,0 +1,221 @@
+/* Static MCP stdio runtime — copied verbatim into emitted packages by codegen-mcp.ts.
+ * Consumes a Tool[] array + SDK instance. Wires MCP low-level Server class to
+ * stdio JSON-RPC. Maps SDK client errors -> { isError: true, content: [...] }.
+ *
+ * Intentional choice of low-level `Server` over `McpServer`: tool inputSchema is
+ * already JSON Schema (emitted from OpenAPI). `McpServer.registerTool` requires
+ * zod; switching would mean carrying json-schema-to-zod at runtime for zero gain.
+ * `Server` is marked @deprecated but the SDK's own guidance says to use it for
+ * advanced/codegen cases — keep until SDK exposes a JSON-Schema-native path. */
+
+/* eslint-disable @typescript-eslint/no-deprecated */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js"
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js"
+import type { Tool, ToolResult } from "./types.ts"
+
+type ServerError = Error & { status?: number; body?: unknown; data?: unknown }
+
+/** Per argument group, the keys a tool may forward (`true`: the whole JSON body). */
+export type AllowedArgs = { headers?: string[]; json?: true; params?: string[]; search?: string[] }
+
+/* Tool results go into a model's context: cap them. */
+const MAX_RESULT_CHARS = 100_000
+
+function errorResult(message: string, extra: Record<string, unknown> = {}): ToolResult {
+	return { content: [{ text: JSON.stringify({ message, ...extra }), type: "text" }], isError: true }
+}
+
+function typeOf(value: unknown): string {
+	if (value === null) return "null"
+	if (Array.isArray(value)) return "array"
+	if (typeof value === "number") return Number.isInteger(value) ? "integer" : "number"
+	return typeof value
+}
+
+function matchesType(value: unknown, type: unknown): boolean {
+	if (type === undefined) return true
+	const types = Array.isArray(type) ? type : [type]
+	const actual = typeOf(value)
+	return types.some((t) => t === actual || (t === "number" && actual === "integer"))
+}
+
+/**
+ * The subset of JSON Schema that OpenAPI-derived tool schemas use: type, required,
+ * properties, items, enum, const, nullable. Enough to reject malformed arguments before
+ * they reach the API; the server validates the rest.
+ */
+export function validateArgs(schema: Record<string, unknown>, value: unknown, path = "arguments"): string[] {
+	const errors: string[] = []
+	if (value === null && schema.nullable === true) return errors
+	if (!matchesType(value, schema.type)) {
+		errors.push(`${path}: expected ${JSON.stringify(schema.type)}, got ${typeOf(value)}`)
+		return errors
+	}
+	if (Array.isArray(schema.enum) && !schema.enum.some((e) => JSON.stringify(e) === JSON.stringify(value))) {
+		errors.push(`${path}: must be one of ${JSON.stringify(schema.enum)}`)
+	}
+	if ("const" in schema && JSON.stringify(schema.const) !== JSON.stringify(value)) {
+		errors.push(`${path}: must be ${JSON.stringify(schema.const)}`)
+	}
+	if (typeOf(value) === "object") {
+		const obj = value as Record<string, unknown>
+		const props = (schema.properties ?? {}) as Record<string, Record<string, unknown>>
+		for (const key of (schema.required ?? []) as string[]) {
+			if (!Object.hasOwn(obj, key) || obj[key] === undefined) errors.push(`${path}.${key}: required`)
+		}
+		for (const [key, sub] of Object.entries(props)) {
+			if (Object.hasOwn(obj, key) && obj[key] !== undefined)
+				errors.push(...validateArgs(sub, obj[key], `${path}.${key}`))
+		}
+	}
+	if (Array.isArray(value) && schema.items && typeof schema.items === "object") {
+		value.forEach((item, i) =>
+			errors.push(...validateArgs(schema.items as Record<string, unknown>, item, `${path}[${i}]`)),
+		)
+	}
+	return errors
+}
+
+function pick(source: unknown, keys: string[]): Record<string, unknown> | undefined {
+	if (source === null || typeof source !== "object" || Array.isArray(source)) return undefined
+	const out: Record<string, unknown> = {}
+	for (const key of keys) {
+		if (Object.hasOwn(source, key) && (source as Record<string, unknown>)[key] !== undefined) {
+			out[key] = (source as Record<string, unknown>)[key]
+		}
+	}
+	return Object.keys(out).length > 0 ? out : undefined
+}
+
+function formatResult(result: unknown): ToolResult {
+	let text: string
+	if (typeof result === "string") text = result
+	else if (result instanceof ArrayBuffer || ArrayBuffer.isView(result)) {
+		const bytes = result instanceof ArrayBuffer ? result.byteLength : result.byteLength
+		text = JSON.stringify({ binary: true, bytes, message: "binary response not shown" })
+	} else if (typeof Blob !== "undefined" && result instanceof Blob) {
+		text = JSON.stringify({ binary: true, bytes: result.size, message: "binary response not shown", type: result.type })
+	} else text = JSON.stringify(result ?? null)
+	if (text.length > MAX_RESULT_CHARS) {
+		text = `${text.slice(0, MAX_RESULT_CHARS)}\n[truncated: ${text.length} characters, showing ${MAX_RESULT_CHARS}]`
+	}
+	return { content: [{ text, type: "text" }] }
+}
+
+/**
+ * Run one tool call: validate `args` against the tool's input schema, forward only the keys
+ * the operation declares (never extra headers, cookies or a raw body), refuse path params that
+ * would change the request path, and call the SDK method at `segments`.
+ */
+export async function callTool(
+	sdk: unknown,
+	segments: string[],
+	args: Record<string, unknown>,
+	inputSchema: Record<string, unknown>,
+	allowed: AllowedArgs,
+): Promise<ToolResult> {
+	const errors = validateArgs(inputSchema, args ?? {})
+	if (errors.length > 0) return errorResult("Invalid tool arguments", { errors: errors.slice(0, 20) })
+
+	const input: Record<string, unknown> = {}
+	for (const group of ["params", "search", "headers"] as const) {
+		const keys = allowed[group]
+		if (!keys) continue
+		const picked = pick(args[group], keys)
+		if (picked) input[group] = picked
+	}
+	if (allowed.json && args.json !== undefined) input.json = args.json
+
+	const params = input.params as Record<string, unknown> | undefined
+	for (const [key, value] of Object.entries(params ?? {})) {
+		const text = String(value)
+		if (text === "" || text === "." || text === "..") {
+			return errorResult(`Invalid path parameter ${JSON.stringify(key)}: ${JSON.stringify(text)}`)
+		}
+		params![key] = text
+	}
+
+	let method: unknown = sdk
+	let owner: unknown = sdk
+	for (const seg of segments) {
+		owner = method
+		method = method !== null && typeof method === "object" ? (method as Record<string, unknown>)[seg] : undefined
+	}
+	if (typeof method !== "function") return errorResult(`SDK missing method ${segments.join(".")}`)
+	return formatResult(await (method as (input: unknown) => Promise<unknown>).call(owner, input))
+}
+
+function formatError(err: unknown): ToolResult {
+	if (err instanceof Error) {
+		const e = err as ServerError
+		const status = typeof e.status === "number" ? e.status : 0
+		const payload: Record<string, unknown> = {
+			message: e.message,
+			name: e.name,
+		}
+		if (status > 0) payload.status = status
+		if (e.data !== undefined) payload.data = e.data
+		else if (e.body !== undefined) payload.data = e.body
+		const text = JSON.stringify(payload)
+		return {
+			content: [{ text: text.length > MAX_RESULT_CHARS ? `${text.slice(0, MAX_RESULT_CHARS)}…` : text, type: "text" }],
+			isError: true,
+		}
+	}
+	return {
+		content: [{ text: JSON.stringify({ message: String(err) }), type: "text" }],
+		isError: true,
+	}
+}
+
+export async function createMCPServer(options: {
+	tools: Tool[]
+	sdk: unknown
+	serverInfo: { name: string; version: string }
+}): Promise<void> {
+	const { tools, sdk, serverInfo } = options
+
+	const server = new Server(serverInfo, {
+		capabilities: { tools: {} },
+	})
+
+	server.setRequestHandler(ListToolsRequestSchema, () => {
+		return {
+			tools: tools.map((t) => ({
+				description: t.description,
+				inputSchema: t.inputSchema,
+				name: t.name,
+			})),
+		}
+	})
+
+	server.setRequestHandler(CallToolRequestSchema, async (request) => {
+		const { name, arguments: args } = request.params
+		const tool = tools.find((t) => t.name === name)
+		if (!tool) {
+			return {
+				content: [{ text: JSON.stringify({ message: `Unknown tool: ${name}` }), type: "text" }],
+				isError: true,
+			}
+		}
+		try {
+			return await tool.handler((args ?? {}) as Record<string, unknown>, sdk)
+		} catch (err: unknown) {
+			return formatError(err)
+		}
+	})
+
+	const transport = new StdioServerTransport()
+
+	/* graceful shutdown on SIGTERM / stdin close — stdio transport closes on stdin EOF,
+	 * Server.close() flushes pending responses, process.exit(0) per MCP conventions. */
+	const shutdown = (): void => {
+		void server.close().finally(() => process.exit(0))
+	}
+	process.on("SIGTERM", shutdown)
+	process.on("SIGINT", shutdown)
+	process.stdin.on("end", shutdown)
+
+	await server.connect(transport)
+}

package/dist/client-mcp/types.ts

@@ -0,0 +1,19 @@
+/* Static MCP runtime types — copied verbatim into emitted packages by codegen-mcp.ts.
+ * No @modelcontextprotocol/sdk imports here: keeps type surface decoupled from the
+ * SDK so callers (tool authors) only depend on this shared shape. */
+
+export type ToolContent = { type: "text"; text: string }
+
+export type ToolResult = {
+	content: ToolContent[]
+	isError?: boolean
+}
+
+export type ToolHandler = (args: Record<string, unknown>, sdk: unknown) => Promise<ToolResult>
+
+export type Tool = {
+	name: string
+	description?: string
+	inputSchema: Record<string, unknown>
+	handler: ToolHandler
+}

package/dist/client-python/_errors.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+
+class APIError(Exception):
+    """Base class for all API errors."""
+
+    status: int
+    body: Any
+    data: Any
+    response: httpx.Response
+    message: str
+
+    def __init__(
+        self,
+        *,
+        status: int,
+        body: Any,
+        data: Any,
+        response: httpx.Response,
+        message: str,
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        self.body = body
+        self.data = data
+        self.response = response
+        self.message = message
+
+    def __repr__(self) -> str:
+        cls = self.__class__.__name__
+        return f"{cls}(status={self.status}, message={self.message!r})"
+
+
+class BadRequestError(APIError):
+    """HTTP 400 Bad Request."""
+
+
+class UnauthorizedError(APIError):
+    """HTTP 401 Unauthorized."""
+
+
+class ForbiddenError(APIError):
+    """HTTP 403 Forbidden."""
+
+
+class NotFoundError(APIError):
+    """HTTP 404 Not Found."""
+
+
+class ConflictError(APIError):
+    """HTTP 409 Conflict."""
+
+
+class UnprocessableEntityError(APIError):
+    """HTTP 422 Unprocessable Entity."""
+
+
+class RateLimitError(APIError):
+    """HTTP 429 Too Many Requests."""
+
+
+class InternalServerError(APIError):
+    """HTTP 500 Internal Server Error."""
+
+
+class BadGatewayError(APIError):
+    """HTTP 502 Bad Gateway."""
+
+
+class ServiceUnavailableError(APIError):
+    """HTTP 503 Service Unavailable."""
+
+
+class GatewayTimeoutError(APIError):
+    """HTTP 504 Gateway Timeout."""
+
+
+class APIStatusError(APIError):
+    """Fallback for any 4xx/5xx status not covered by a named subclass."""
+
+
+_STATUS_ERROR_MAP: dict[int, type[APIError]] = {
+    400: BadRequestError,
+    401: UnauthorizedError,
+    403: ForbiddenError,
+    404: NotFoundError,
+    409: ConflictError,
+    422: UnprocessableEntityError,
+    429: RateLimitError,
+    500: InternalServerError,
+    502: BadGatewayError,
+    503: ServiceUnavailableError,
+    504: GatewayTimeoutError,
+}
+
+__all__ = [
+    "APIError",
+    "APIStatusError",
+    "BadGatewayError",
+    "BadRequestError",
+    "ConflictError",
+    "ForbiddenError",
+    "GatewayTimeoutError",
+    "InternalServerError",
+    "NotFoundError",
+    "RateLimitError",
+    "ServiceUnavailableError",
+    "UnauthorizedError",
+    "UnprocessableEntityError",
+    "_STATUS_ERROR_MAP",
+]