@lovrozagar/honey 0.1.0

package/src/client-go/transport.go

@@ -0,0 +1,452 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+
+	"nhooyr.io/websocket"
+)
+
+// TransportKind tags which transport a connection was opened with.
+// Mirrors Rust TransportKind / Python TransportKind.
+type TransportKind string
+
+const (
+	TransportWs       TransportKind = "ws"
+	TransportSse      TransportKind = "sse"
+	TransportLongpoll TransportKind = "longpoll"
+)
+
+// TransportOpts is handed to each Transport.Connect call. Mirrors the TS
+// TransportOpts plus per-language extras (HTTPClient for SSE/longpoll dial).
+type TransportOpts struct {
+	ReconnectToken       string
+	LastEventID          string
+	Headers              http.Header
+	MaxReconnectAttempts int
+	ReconnectDelayMs     int
+	Protocols            []string
+	HTTPClient           *http.Client
+}
+
+// TransportConn is the live per-transport connection object. Each built-in
+// adapter returns its own impl (wsConn, sseConn, longpollConn). Recv returns
+// decoded JSON (map[string]any, []any, string, number, bool) or raw string
+// fallback when the payload is not JSON.
+type TransportConn interface {
+	Recv(ctx context.Context) (any, error)
+	Send(ctx context.Context, data any) error
+	Close() error
+	Kind() TransportKind
+}
+
+// Transport is the pluggable adapter interface. Consumers swap in their own
+// WS/SSE/longpoll impls by implementing this. Mirrors Rust trait Transport
+// and Python TransportAdapter Protocol.
+type Transport interface {
+	Name() string
+	Kind() TransportKind
+	Connect(ctx context.Context, url string, opts *TransportOpts) (TransportConn, error)
+}
+
+/* errTransportNotImplemented remains as a transitional sentinel from the 8.b.3
+ * stub phase. Real Connect bodies below no longer return it; kept to avoid
+ * breaking any consumer that wrote defensive errors.Is checks. Removal deferred
+ * to 8.d cleanup. */
+var errTransportNotImplemented = errors.New("honey: transport adapter Connect not implemented")
+
+/* ───────────────────────── WebSocket adapter ───────────────────────── */
+
+// WsTransport is the default WebSocket adapter. Wraps nhooyr.io/websocket.
+type WsTransport struct {
+	Subprotocols []string
+}
+
+// Name returns "ws".
+func (t *WsTransport) Name() string { return "ws" }
+
+// Kind returns TransportWs.
+func (t *WsTransport) Kind() TransportKind { return TransportWs }
+
+// Connect dials the WebSocket endpoint. Auth + resume tokens ride as query
+// params on the URL; protocols + headers come from opts. Returned conn is a
+// *wsConn satisfying TransportConn.
+func (t *WsTransport) Connect(ctx context.Context, rawURL string, opts *TransportOpts) (TransportConn, error) {
+	wsURL := toWsURL(rawURL)
+	if opts != nil {
+		q := url.Values{}
+		if opts.ReconnectToken != "" {
+			q.Set("reconnect_token", opts.ReconnectToken)
+		}
+		if opts.LastEventID != "" {
+			q.Set("last_event_id", opts.LastEventID)
+		}
+		if len(q) > 0 {
+			sep := "?"
+			if strings.Contains(wsURL, "?") {
+				sep = "&"
+			}
+			wsURL = wsURL + sep + q.Encode()
+		}
+	}
+	dialOpts := &websocket.DialOptions{}
+	if opts != nil {
+		if len(opts.Protocols) > 0 {
+			dialOpts.Subprotocols = opts.Protocols
+		}
+		if len(opts.Headers) > 0 {
+			dialOpts.HTTPHeader = opts.Headers.Clone()
+		}
+	}
+	if dialOpts.Subprotocols == nil && len(t.Subprotocols) > 0 {
+		dialOpts.Subprotocols = t.Subprotocols
+	}
+	conn, _, err := websocket.Dial(ctx, wsURL, dialOpts)
+	if err != nil {
+		return nil, err
+	}
+	return &wsConn{conn: conn}, nil
+}
+
+type wsConn struct {
+	conn *websocket.Conn
+}
+
+func (c *wsConn) Kind() TransportKind { return TransportWs }
+
+func (c *wsConn) Recv(ctx context.Context) (any, error) {
+	_, data, err := c.conn.Read(ctx)
+	if err != nil {
+		return nil, err
+	}
+	var v any
+	if jsonErr := json.Unmarshal(data, &v); jsonErr != nil {
+		/* non-JSON payload — fall through to raw string (matches Python decode). */
+		return string(data), nil
+	}
+	return v, nil
+}
+
+func (c *wsConn) Send(ctx context.Context, data any) error {
+	switch v := data.(type) {
+	case []byte:
+		return c.conn.Write(ctx, websocket.MessageBinary, v)
+	case string:
+		return c.conn.Write(ctx, websocket.MessageText, []byte(v))
+	default:
+		encoded, err := json.Marshal(v)
+		if err != nil {
+			return err
+		}
+		return c.conn.Write(ctx, websocket.MessageText, encoded)
+	}
+}
+
+func (c *wsConn) Close() error {
+	return c.conn.Close(websocket.StatusNormalClosure, "client close")
+}
+
+func toWsURL(u string) string {
+	if strings.HasPrefix(u, "https://") {
+		return "wss://" + u[len("https://"):]
+	}
+	if strings.HasPrefix(u, "http://") {
+		return "ws://" + u[len("http://"):]
+	}
+	return u
+}
+
+/* ────────────────────────────── SSE adapter ────────────────────────────── */
+
+// SseTransport is the default SSE adapter. Uses net/http streaming GET via
+// parseSSEStream. A background goroutine bridges the iterator to a Recv channel
+// so ResumableConnection.Recv has uniform blocking semantics across transports.
+type SseTransport struct {
+	HTTPClient *http.Client
+}
+
+// Name returns "sse".
+func (t *SseTransport) Name() string { return "sse" }
+
+// Kind returns TransportSse.
+func (t *SseTransport) Kind() TransportKind { return TransportSse }
+
+// Connect opens the SSE byte stream. Reconnect token rides as a query param;
+// Last-Event-ID rides as a request header (HTML spec).
+func (t *SseTransport) Connect(ctx context.Context, rawURL string, opts *TransportOpts) (TransportConn, error) {
+	client := t.HTTPClient
+	if opts != nil && opts.HTTPClient != nil {
+		client = opts.HTTPClient
+	}
+	if client == nil {
+		client = http.DefaultClient
+	}
+
+	u := rawURL
+	if opts != nil && opts.ReconnectToken != "" {
+		sep := "?"
+		if strings.Contains(u, "?") {
+			sep = "&"
+		}
+		u = u + sep + "reconnect_token=" + url.QueryEscape(opts.ReconnectToken)
+	}
+	req, err := http.NewRequestWithContext(ctx, "GET", u, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Accept", "text/event-stream")
+	if opts != nil {
+		for k, vv := range opts.Headers {
+			for _, v := range vv {
+				req.Header.Add(k, v)
+			}
+		}
+		if opts.LastEventID != "" {
+			req.Header.Set("Last-Event-ID", opts.LastEventID)
+		}
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		_ = resp.Body.Close()
+		return nil, fmt.Errorf("honey: sse transport: status %d", resp.StatusCode)
+	}
+	sc := &sseConn{
+		resp: resp,
+		next: make(chan sseResult, 1),
+		done: make(chan struct{}),
+	}
+	go sc.run(ctx)
+	return sc, nil
+}
+
+type sseResult struct {
+	value any
+	err   error
+}
+
+type sseConn struct {
+	resp   *http.Response
+	next   chan sseResult
+	done   chan struct{}
+	mu     sync.Mutex
+	closed bool
+}
+
+func (c *sseConn) Kind() TransportKind { return TransportSse }
+
+func (c *sseConn) run(ctx context.Context) {
+	defer c.finish()
+	for ev, err := range parseSSEStream(ctx, c.resp) {
+		select {
+		case <-c.done:
+			return
+		default:
+		}
+		if err != nil {
+			select {
+			case c.next <- sseResult{err: err}:
+			case <-c.done:
+			}
+			return
+		}
+		var v any
+		if jsonErr := json.Unmarshal([]byte(ev.Data), &v); jsonErr != nil {
+			v = ev.Data
+		}
+		select {
+		case c.next <- sseResult{value: v}:
+		case <-c.done:
+			return
+		}
+	}
+}
+
+func (c *sseConn) finish() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.closed {
+		return
+	}
+	c.closed = true
+	close(c.next)
+}
+
+func (c *sseConn) Recv(ctx context.Context) (any, error) {
+	select {
+	case r, ok := <-c.next:
+		if !ok {
+			return nil, io.EOF
+		}
+		return r.value, r.err
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
+}
+
+func (c *sseConn) Send(ctx context.Context, data any) error {
+	return errors.New("honey: sse transport is receive-only")
+}
+
+func (c *sseConn) Close() error {
+	c.mu.Lock()
+	alreadyClosed := c.closed
+	c.mu.Unlock()
+	/* signal producer, then close body — parseSSEStream closes body on its own
+	 * iterator exit, but bodyClose here is idempotent for the already-closed
+	 * case via Body.Close()'s stdlib contract. */
+	select {
+	case <-c.done:
+	default:
+		close(c.done)
+	}
+	if !alreadyClosed {
+		return c.resp.Body.Close()
+	}
+	return nil
+}
+
+/* ──────────────────────────── Longpoll adapter ─────────────────────────── */
+
+// LongpollTransport is the default long-poll adapter. Each Recv fires a GET
+// against the configured URL with cursor query params and blocks until the
+// server replies. Payloads that look like JSON objects have their
+// reconnect_token / id / last_event_id fields harvested to advance the cursor.
+type LongpollTransport struct {
+	HTTPClient *http.Client
+}
+
+// Name returns "longpoll".
+func (t *LongpollTransport) Name() string { return "longpoll" }
+
+// Kind returns TransportLongpoll.
+func (t *LongpollTransport) Kind() TransportKind { return TransportLongpoll }
+
+// Connect constructs the longpoll conn; no wire traffic until first Recv.
+func (t *LongpollTransport) Connect(ctx context.Context, rawURL string, opts *TransportOpts) (TransportConn, error) {
+	client := t.HTTPClient
+	if opts != nil && opts.HTTPClient != nil {
+		client = opts.HTTPClient
+	}
+	if client == nil {
+		client = http.DefaultClient
+	}
+	lp := &longpollConn{
+		client:  client,
+		url:     rawURL,
+		headers: http.Header{},
+	}
+	if opts != nil {
+		lp.reconnectToken = opts.ReconnectToken
+		lp.lastEventID = opts.LastEventID
+		if opts.Headers != nil {
+			lp.headers = opts.Headers.Clone()
+		}
+	}
+	return lp, nil
+}
+
+type longpollConn struct {
+	client         *http.Client
+	url            string
+	headers        http.Header
+	reconnectToken string
+	lastEventID    string
+	mu             sync.Mutex
+	closed         bool
+}
+
+func (c *longpollConn) Kind() TransportKind { return TransportLongpoll }
+
+func (c *longpollConn) Recv(ctx context.Context) (any, error) {
+	c.mu.Lock()
+	if c.closed {
+		c.mu.Unlock()
+		return nil, io.EOF
+	}
+	token := c.reconnectToken
+	lastID := c.lastEventID
+	headers := c.headers
+	c.mu.Unlock()
+
+	q := url.Values{}
+	if token != "" {
+		q.Set("reconnect_token", token)
+	}
+	if lastID != "" {
+		q.Set("last_event_id", lastID)
+	}
+	u := c.url
+	if len(q) > 0 {
+		sep := "?"
+		if strings.Contains(u, "?") {
+			sep = "&"
+		}
+		u = u + sep + q.Encode()
+	}
+	req, err := http.NewRequestWithContext(ctx, "GET", u, nil)
+	if err != nil {
+		return nil, err
+	}
+	for k, vv := range headers {
+		for _, v := range vv {
+			req.Header.Add(k, v)
+		}
+	}
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, fmt.Errorf("honey: longpoll transport: status %d", resp.StatusCode)
+	}
+	var v any
+	if jsonErr := json.Unmarshal(body, &v); jsonErr != nil {
+		v = string(body)
+	}
+	if m, ok := v.(map[string]any); ok {
+		c.mu.Lock()
+		if tok, ok := m["reconnect_token"].(string); ok {
+			c.reconnectToken = tok
+		}
+		if id, ok := m["id"].(string); ok {
+			c.lastEventID = id
+		}
+		if id, ok := m["last_event_id"].(string); ok {
+			c.lastEventID = id
+		}
+		c.mu.Unlock()
+	}
+	return v, nil
+}
+
+func (c *longpollConn) Send(ctx context.Context, data any) error {
+	return errors.New("honey: longpoll transport is receive-only")
+}
+
+func (c *longpollConn) Close() error {
+	c.mu.Lock()
+	c.closed = true
+	c.mu.Unlock()
+	return nil
+}
+
+/* internal sentinel used by tests; exported-like lowercase to keep public
+ * surface unchanged from 8.b.3. */
+var _ = errTransportNotImplemented

package/src/client-go/ws.go

@@ -0,0 +1,104 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"context"
+	"encoding/json"
+	"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
+
+// TypedWebSocket wraps a nhooyr.io/websocket connection with a buffered send
+// queue (pre-OPEN) and an event fanout system that mirrors the TS client's .on()
+// escape hatch.
+//
+// Pre-OPEN buffering: sends before the first read are queued in sendBuffer and
+// flushed on the first successful read via sync.Once — matches TS client.ws.ts.
+type TypedWebSocket struct {
+	conn        *websocket.Conn
+	sendBuffer  []byte
+	once        sync.Once
+	mu          sync.Mutex
+	handlers    map[string][]func(data []byte)
+	dialOptions websocket.DialOptions
+}
+
+// newTypedWebSocket constructs a TypedWebSocket from an already-dialled conn.
+func newTypedWebSocket(conn *websocket.Conn) *TypedWebSocket {
+	return &TypedWebSocket{
+		conn:     conn,
+		handlers: make(map[string][]func(data []byte)),
+	}
+}
+
+// Send serialises data to JSON when it is a struct or map, passes []byte and
+// string through as-is. Sends are buffered until the first Read call flushes them.
+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.
+func (w *TypedWebSocket) Close(code websocket.StatusCode, reason string) error {
+	return w.conn.Close(code, reason)
+}
+
+// Read reads the next message from the connection.
+// On the first call, any pre-OPEN buffered send is flushed via sync.Once.
+func (w *TypedWebSocket) Read(ctx context.Context) ([]byte, error) {
+	w.once.Do(func() {
+		if len(w.sendBuffer) > 0 {
+			_ = w.conn.Write(ctx, websocket.MessageText, w.sendBuffer)
+			w.sendBuffer = nil
+		}
+	})
+	_, msg, err := w.conn.Read(ctx)
+	if err != nil {
+		return nil, err
+	}
+	w.fanout("message", msg)
+	return msg, nil
+}
+
+// On registers an event handler. Supported events: "message", "close", "error", "open".
+// 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) fanout(event string, data []byte) {
+	w.mu.Lock()
+	handlers := 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/src/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/src/client-mcp/server.ts

@@ -0,0 +1,94 @@
+/* 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 }
+
+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
+		return {
+			content: [{ text: JSON.stringify(payload), 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 {
+			const result = await tool.handler((args ?? {}) as Record<string, unknown>, sdk)
+			return result
+		} 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/src/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
+}