@typerighter/rpc-client 0.38.1 → 0.40.0

package/.gitignore

@@ -0,0 +1 @@
+dist/

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@typerighter/rpc-client",
-  "version": "0.38.1",
+  "version": "0.40.0",
   "description": "JSON-RPC client for Typedown over TCP/stdio.",
   "repository": {
     "type": "git",

package/src/index.ts

@@ -99,6 +99,8 @@ export interface TdSchemaInfo {
 export interface TdSiteConfig {
   version: string;
   basePath: string;
+  origin: string | undefined;
+  lang: string;
   rootDir: string;
   siteTitle: string;
   siteDescription: string;
@@ -109,6 +111,12 @@ export interface TdSiteConfig {
   nav: TdNavItem[];
 }
 
+export interface TdPageMeta {
+  title?: string;
+  description?: string;
+  image?: string;
+}
+
 export interface TdBuiltResource {
   schema?: string;
   schemaLabel?: string;
@@ -119,6 +127,7 @@ export interface TdBuiltResource {
   headings: TdHeading[];
   title?: string;
   metadata: TdFileMetadata;
+  meta?: TdPageMeta;
 }
 
 // Server-reserved JSON-RPC error code for cancelled queries (-32000 to -32099)

package/dist/core/client.d.ts

@@ -1,54 +0,0 @@
-/**
- * JSON-RPC 2.0 client with Content-Length framing
- * Simplified from vscode-jsonrpc (MIT, Microsoft Corporation)
- * Ref: https://github.com/microsoft/vscode-languageserver-node/blob/5010cdf9822e1038a30ee7eb6ee5d7aaa79acc4a/jsonrpc/src/common/connection.ts#L506-L591
- */
-import type { Readable, Writable } from 'node:stream';
-interface Disposable {
-    dispose(): void;
-}
-/**
- * Simplified MessageConnection interface
- * https://github.com/microsoft/vscode-languageserver-node/blob/5010cdf9822e1038a30ee7eb6ee5d7aaa79acc4a/jsonrpc/src/common/connection.ts#L506-L591
- */
-export interface MessageConnection extends Disposable {
-    /** Send a JSON-RPC request and wait for the response */
-    sendRequest<R>(method: string, params?: any[] | object): Promise<R>;
-    /** Send a one-way JSON-RPC notification (no response expected) */
-    sendNotification(method: string, params?: any[] | object): void;
-    /** Register a handler for server-sent notifications, returns an unsubscribe handle */
-    onNotification(method: string, handler: (params: any) => void): Disposable;
-    /** Register a listener for connection close, returns an unsubscribe handle */
-    onClose(listener: () => void): Disposable;
-    /** Reject all pending requests and stop listening */
-    dispose(): void;
-}
-export declare class JsonRpcClient implements MessageConnection {
-    private reader;
-    private writer;
-    private sequenceNumber;
-    private responsePromises;
-    private notificationHandlers;
-    private chunks;
-    private chunksLength;
-    private contentLength;
-    private disposed;
-    private closeHandlers;
-    constructor(reader: Readable, writer: Writable);
-    static connectTcp(host: string, port: number): Promise<JsonRpcClient>;
-    static connectStdio(stdin: Readable, stdout: Writable): JsonRpcClient;
-    dispose(): void;
-    onClose(listener: () => void): Disposable;
-    sendRequest<R>(method: string, params?: any[] | object): Promise<R>;
-    sendNotification(method: string, params?: any[] | object): void;
-    onNotification(method: string, handler: (params: any) => void): Disposable;
-    private onData;
-    private handleResponse;
-    private handleNotification;
-    private rejectAllPending;
-    private handleStreamClose;
-    private writeMessage;
-    private compact;
-    private consume;
-}
-export {};

package/dist/core/client.js

@@ -1,209 +0,0 @@
-/**
- * JSON-RPC 2.0 client with Content-Length framing
- * Simplified from vscode-jsonrpc (MIT, Microsoft Corporation)
- * Ref: https://github.com/microsoft/vscode-languageserver-node/blob/5010cdf9822e1038a30ee7eb6ee5d7aaa79acc4a/jsonrpc/src/common/connection.ts#L506-L591
- */
-import { createConnection } from 'node:net';
-import { Message as MessageGuards, ErrorCodes, ResponseError } from './types.js';
-const HEADER_SEPARATOR = Buffer.from('\r\n\r\n', 'ascii');
-const HEADER_SEPARATOR_LENGTH = 4; // \r\n\r\n
-export class JsonRpcClient {
-    // Transport
-    reader;
-    writer;
-    // Request/response matching
-    sequenceNumber = 1;
-    responsePromises = new Map();
-    notificationHandlers = new Map();
-    // Inbound buffer, raw chunks to avoid corrupting multi-byte UTF-8
-    chunks = [];
-    chunksLength = 0;
-    contentLength = -1; // -1 = waiting for header
-    // Lifecycle
-    disposed = false;
-    closeHandlers = [];
-    constructor(reader, writer) {
-        this.reader = reader;
-        this.writer = writer;
-        this.reader.on('data', (chunk) => this.onData(chunk));
-        this.reader.on('end', () => this.handleStreamClose());
-        this.reader.on('close', () => this.handleStreamClose());
-    }
-    static connectTcp(host, port) {
-        return new Promise((resolve, reject) => {
-            const socket = createConnection({ host, port }, () => {
-                resolve(new JsonRpcClient(socket, socket));
-            });
-            socket.on('error', reject);
-        });
-    }
-    static connectStdio(stdin, stdout) {
-        return new JsonRpcClient(stdin, stdout);
-    }
-    // https://github.com/microsoft/vscode-languageserver-node/blob/5010cdf9822e1038a30ee7eb6ee5d7aaa79acc4a/jsonrpc/src/common/connection.ts#L1563-L1590
-    dispose() {
-        if (this.disposed)
-            return;
-        this.disposed = true;
-        this.rejectAllPending('Connection disposed');
-        // Close the streams so the server detects the disconnect
-        this.reader.destroy();
-        this.writer.destroy();
-    }
-    // https://github.com/microsoft/vscode-languageserver-node/blob/5010cdf9822e1038a30ee7eb6ee5d7aaa79acc4a/jsonrpc/src/common/connection.ts#L565
-    onClose(listener) {
-        this.closeHandlers.push(listener);
-        return {
-            dispose: () => {
-                const index = this.closeHandlers.indexOf(listener);
-                if (index >= 0)
-                    this.closeHandlers.splice(index, 1);
-            },
-        };
-    }
-    // https://github.com/microsoft/vscode-languageserver-node/blob/5010cdf9822e1038a30ee7eb6ee5d7aaa79acc4a/jsonrpc/src/common/connection.ts#L537
-    sendRequest(method, params) {
-        const id = this.sequenceNumber++;
-        const message = { jsonrpc: '2.0', id, method, params };
-        return new Promise((resolve, reject) => {
-            this.responsePromises.set(id, { resolve: resolve, reject });
-            this.writeMessage(message);
-        });
-    }
-    // https://github.com/microsoft/vscode-languageserver-node/blob/5010cdf9822e1038a30ee7eb6ee5d7aaa79acc4a/jsonrpc/src/common/connection.ts#L549
-    sendNotification(method, params) {
-        const message = { jsonrpc: '2.0', method, params };
-        this.writeMessage(message);
-    }
-    // https://github.com/microsoft/vscode-languageserver-node/blob/5010cdf9822e1038a30ee7eb6ee5d7aaa79acc4a/jsonrpc/src/common/connection.ts#L557
-    onNotification(method, handler) {
-        const handlers = this.notificationHandlers.get(method) ?? [];
-        handlers.push(handler);
-        this.notificationHandlers.set(method, handlers);
-        return {
-            dispose: () => {
-                const list = this.notificationHandlers.get(method);
-                if (list) {
-                    const idx = list.indexOf(handler);
-                    if (idx !== -1)
-                        list.splice(idx, 1);
-                }
-            },
-        };
-    }
-    // Accumulate chunk and parse as many complete messages as possible
-    // A single chunk can contain multiple messages
-    // Ref: vscode-jsonrpc ReadableStreamMessageReader.nextMessage
-    onData(chunk) {
-        this.chunks.push(chunk);
-        this.chunksLength += chunk.length;
-        while (true) {
-            if (this.contentLength < 0) {
-                const buffer = this.compact();
-                const separatorIndex = buffer.indexOf(HEADER_SEPARATOR);
-                if (separatorIndex < 0)
-                    return;
-                const header = buffer.subarray(0, separatorIndex).toString('ascii');
-                const match = header.match(/Content-Length:\s*(\d+)/i);
-                if (!match) {
-                    this.consume(separatorIndex + HEADER_SEPARATOR_LENGTH);
-                    continue;
-                }
-                this.contentLength = Number(match[1]);
-                this.consume(separatorIndex + HEADER_SEPARATOR_LENGTH);
-            }
-            if (this.chunksLength < this.contentLength)
-                return;
-            const buffer = this.compact();
-            const body = buffer.subarray(0, this.contentLength).toString('utf-8');
-            this.consume(this.contentLength);
-            this.contentLength = -1;
-            try {
-                const message = JSON.parse(body);
-                if (MessageGuards.isResponse(message)) {
-                    this.handleResponse(message);
-                }
-                else if (MessageGuards.isNotification(message)) {
-                    this.handleNotification(message);
-                }
-            }
-            catch (error) {
-                console.error('[jsonrpc] Failed to parse message:', error);
-            }
-        }
-    }
-    // Ref: vscode-jsonrpc connection.ts
-    handleResponse(response) {
-        if (typeof response.id !== 'number')
-            return;
-        const pending = this.responsePromises.get(response.id);
-        if (!pending)
-            return;
-        this.responsePromises.delete(response.id);
-        if (response.error) {
-            pending.reject(new ResponseError(response.error.code, response.error.message, response.error.data));
-        }
-        else if (response.result !== undefined) {
-            pending.resolve(response.result);
-        }
-    }
-    handleNotification(notification) {
-        const handlers = this.notificationHandlers.get(notification.method);
-        if (!handlers?.length)
-            return;
-        for (const handler of handlers) {
-            try {
-                handler(notification.params);
-            }
-            catch (error) {
-                console.error(`[jsonrpc] Notification handler for '${notification.method}' threw:`, error);
-            }
-        }
-    }
-    // Cleanup
-    rejectAllPending(reason) {
-        for (const [, pending] of this.responsePromises) {
-            pending.reject(new ResponseError(ErrorCodes.PendingResponseRejected, reason));
-        }
-        this.responsePromises.clear();
-    }
-    // Fires once on stream end/close
-    handleStreamClose() {
-        if (this.disposed)
-            return;
-        this.disposed = true;
-        this.rejectAllPending('Server disconnected');
-        for (const handler of this.closeHandlers) {
-            handler();
-        }
-    }
-    /* Helpers */
-    // Single buffer write to prevent interleaving under concurrent requests
-    writeMessage(message) {
-        const body = Buffer.from(JSON.stringify(message), 'utf-8');
-        const header = Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, 'ascii');
-        this.writer.write(Buffer.concat([header, body]));
-    }
-    // Concat all chunks into 1 buffer
-    compact() {
-        if (this.chunks.length === 1)
-            return this.chunks[0];
-        const buffer = Buffer.concat(this.chunks);
-        this.chunks = [buffer];
-        this.chunksLength = buffer.length;
-        return buffer;
-    }
-    // Consume n bytes from buffer
-    consume(bytes) {
-        const buffer = this.compact();
-        const remaining = buffer.subarray(bytes);
-        if (remaining.length > 0) {
-            this.chunks = [remaining];
-            this.chunksLength = remaining.length;
-        }
-        else {
-            this.chunks = [];
-            this.chunksLength = 0;
-        }
-    }
-}

package/dist/core/index.d.ts

@@ -1,2 +0,0 @@
-export { JsonRpcClient, type MessageConnection } from './client.js';
-export { type RequestMessage, type ResponseMessage, type NotificationMessage, type ResponseErrorLiteral, Message, ErrorCodes, ResponseError, } from './types.js';

package/dist/core/index.js

@@ -1,2 +0,0 @@
-export { JsonRpcClient } from './client.js';
-export { Message, ErrorCodes, ResponseError, } from './types.js';

package/dist/core/types.d.ts

@@ -1,53 +0,0 @@
-/**
- * JSON-RPC 2.0 message types and error codes
- * Copied from vscode-jsonrpc (MIT, Microsoft Corporation)
- * Ref: https://github.com/microsoft/vscode-languageserver-node/tree/main/jsonrpc/src/common/messages
- */
-export interface Message {
-    jsonrpc: string;
-}
-export interface RequestMessage extends Message {
-    id: number | string | null;
-    method: string;
-    params?: any[] | object;
-}
-export interface ResponseMessage extends Message {
-    id: number | string | null;
-    result?: string | number | boolean | object | any[] | null;
-    error?: ResponseErrorLiteral<any>;
-}
-export interface NotificationMessage extends Message {
-    method: string;
-    params?: any[] | object;
-}
-export interface ResponseErrorLiteral<D = void> {
-    code: number;
-    message: string;
-    data?: D;
-}
-export declare namespace Message {
-    function isRequest(message: Message | undefined): message is RequestMessage;
-    function isNotification(message: Message | undefined): message is NotificationMessage;
-    function isResponse(message: Message | undefined): message is ResponseMessage;
-}
-export declare namespace ErrorCodes {
-    const ParseError: -32700;
-    const InvalidRequest: -32600;
-    const MethodNotFound: -32601;
-    const InvalidParams: -32602;
-    const InternalError: -32603;
-    const jsonrpcReservedErrorRangeStart: -32099;
-    const MessageWriteError: -32099;
-    const MessageReadError: -32098;
-    const PendingResponseRejected: -32097;
-    const ConnectionInactive: -32096;
-    const ServerNotInitialized: -32002;
-    const UnknownErrorCode: -32001;
-    const jsonrpcReservedErrorRangeEnd: -32000;
-}
-export declare class ResponseError<D = void> extends Error {
-    readonly code: number;
-    readonly data: D | undefined;
-    constructor(code: number, message: string, data?: D);
-    toJson(): ResponseErrorLiteral<D>;
-}

package/dist/core/types.js

@@ -1,67 +0,0 @@
-/**
- * JSON-RPC 2.0 message types and error codes
- * Copied from vscode-jsonrpc (MIT, Microsoft Corporation)
- * Ref: https://github.com/microsoft/vscode-languageserver-node/tree/main/jsonrpc/src/common/messages
- */
-// https://github.com/microsoft/vscode-languageserver-node/blob/5010cdf9822e1038a30ee7eb6ee5d7aaa79acc4a/jsonrpc/src/common/messages.ts#L298-L323
-export var Message;
-(function (Message) {
-    function isRequest(message) {
-        const candidate = message;
-        return candidate !== undefined && typeof candidate.method === 'string'
-            && (typeof candidate.id === 'string' || typeof candidate.id === 'number');
-    }
-    Message.isRequest = isRequest;
-    function isNotification(message) {
-        const candidate = message;
-        return candidate !== undefined && typeof candidate.method === 'string'
-            && candidate.id === undefined;
-    }
-    Message.isNotification = isNotification;
-    function isResponse(message) {
-        const candidate = message;
-        return candidate !== undefined
-            && (candidate.result !== undefined || !!candidate.error)
-            && (typeof candidate.id === 'string' || typeof candidate.id === 'number' || candidate.id === null);
-    }
-    Message.isResponse = isResponse;
-})(Message || (Message = {}));
-// https://github.com/microsoft/vscode-languageserver-node/blob/5010cdf9822e1038a30ee7eb6ee5d7aaa79acc4a/jsonrpc/src/common/messages.ts#L32-L83
-export var ErrorCodes;
-(function (ErrorCodes) {
-    ErrorCodes.ParseError = -32700;
-    ErrorCodes.InvalidRequest = -32600;
-    ErrorCodes.MethodNotFound = -32601;
-    ErrorCodes.InvalidParams = -32602;
-    ErrorCodes.InternalError = -32603;
-    // JSON-RPC reserved error range (-32099 to -32000)
-    ErrorCodes.jsonrpcReservedErrorRangeStart = -32099;
-    ErrorCodes.MessageWriteError = -32099;
-    ErrorCodes.MessageReadError = -32098;
-    ErrorCodes.PendingResponseRejected = -32097;
-    ErrorCodes.ConnectionInactive = -32096;
-    ErrorCodes.ServerNotInitialized = -32002;
-    ErrorCodes.UnknownErrorCode = -32001;
-    ErrorCodes.jsonrpcReservedErrorRangeEnd = -32000;
-})(ErrorCodes || (ErrorCodes = {}));
-// https://github.com/microsoft/vscode-languageserver-node/blob/5010cdf9822e1038a30ee7eb6ee5d7aaa79acc4a/jsonrpc/src/common/messages.ts#L128-L148
-export class ResponseError extends Error {
-    code;
-    data;
-    constructor(code, message, data) {
-        super(message);
-        this.code = typeof code === 'number' ? code : ErrorCodes.UnknownErrorCode;
-        this.data = data;
-        Object.setPrototypeOf(this, ResponseError.prototype);
-    }
-    toJson() {
-        const result = {
-            code: this.code,
-            message: this.message,
-        };
-        if (this.data !== undefined) {
-            result.data = this.data;
-        }
-        return result;
-    }
-}

package/dist/index.d.ts

@@ -1,137 +0,0 @@
-/**
- * Typedown RPC client
- *
- * Thin wrapper over JsonRpcClient that provides typed methods
- * matching the Rust RPC server's contract (rpc/contract.rs)
- *
- * The server (typedown-rpc binary) sends notifications for FS changes;
- * register handlers via onContentChanged/onSchemaChanged/onConfigChanged
- */
-import type { Readable, Writable } from 'node:stream';
-export { JsonRpcClient, Message, ResponseError, ErrorCodes } from './core/index.js';
-export type { RequestMessage, ResponseMessage, NotificationMessage, ResponseErrorLiteral } from './core/index.js';
-export interface TdDiagnosticItem {
-    filepath: string;
-    line: number;
-    column: number;
-    severity: string;
-    code: string;
-    message: string;
-}
-export interface TdContentNotification {
-    filepath: string;
-    affectedFiles?: string[];
-}
-export interface TdFileMetadata {
-    mtime: number;
-    ctime: number;
-}
-export interface TdHeading {
-    level: number;
-    title: string;
-    titleHtml: string;
-    slug: string;
-}
-export interface TdSidebarItem {
-    filepath: string;
-    schema?: string;
-    schemaLabel?: string;
-    label?: string;
-    icon?: TdIcon;
-    excerpt?: string;
-    metadata: TdFileMetadata;
-}
-export interface TdContentSummary {
-    filepath: string;
-    schema?: string;
-    schemaLabel?: string;
-    label?: string;
-    icon?: TdIcon;
-    header: Record<string, any>;
-    excerpt?: string;
-    metadata: TdFileMetadata;
-}
-export interface TdNavItem {
-    title: string;
-    link: string;
-    icon?: string;
-}
-export interface TdIcon {
-    name: string;
-}
-export interface TdDiagnosticReport {
-    diagnostics: TdDiagnosticItem[];
-    fileCount: number;
-    errorCount: number;
-    warningCount: number;
-}
-export interface TdFormatResult {
-    content: string;
-    changed: boolean;
-}
-export interface TdSchemaNotification {
-    schema: string;
-}
-export interface TdSchemaInfo {
-    schema: string;
-    label: string;
-    properties: Record<string, any>;
-}
-export interface TdSiteConfig {
-    version: string;
-    basePath: string;
-    rootDir: string;
-    siteTitle: string;
-    siteDescription: string;
-    repo: string | undefined;
-    author: string | undefined;
-    license: string | undefined;
-    publicDir: string;
-    nav: TdNavItem[];
-}
-export interface TdBuiltResource {
-    schema?: string;
-    schemaLabel?: string;
-    label?: string;
-    icon?: TdIcon;
-    header: Record<string, any>;
-    content: string;
-    headings: TdHeading[];
-    title?: string;
-    metadata: TdFileMetadata;
-}
-export declare const RPC_CANCELLED_CODE = -32002;
-/**
- * Typed RPC client for the Typedown build server
- *
- * Wraps a generic JsonRpcClient with typed request methods
- * and notification handlers matching the Rust RPC contract
- */
-export declare class RpcClient {
-    private rpc;
-    private constructor();
-    static connectTcp(host: string, port: number): Promise<RpcClient>;
-    static connectStdio(stdin: Readable, stdout: Writable): RpcClient;
-    /** Send exit notification and close the connection
-     * The detached server will detect the disconnect and save its cache */
-    dispose(): void;
-    onClose(callback: () => void): {
-        dispose: () => void;
-    };
-    requestFile(path: string): Promise<TdBuiltResource>;
-    requestFiles(paths: string[]): Promise<TdBuiltResource[]>;
-    listVault(): Promise<string[]>;
-    listFilesGroupedBySchema(): Promise<Record<string, TdContentSummary[]>>;
-    listSidebar(): Promise<TdSidebarItem[]>;
-    listSchemas(): Promise<string[]>;
-    getSchema(schema: string): Promise<TdSchemaInfo>;
-    getVersion(): Promise<string>;
-    getConfig(): Promise<TdSiteConfig>;
-    checkVault(): Promise<TdDiagnosticReport>;
-    formatFile(path: string): Promise<TdFormatResult>;
-    onContentUpdated(callback: (notification: TdContentNotification) => void): void;
-    onContentDeleted(callback: (notification: TdContentNotification) => void): void;
-    onSchemaUpdated(callback: (notification: TdSchemaNotification) => void): void;
-    onSchemaDeleted(callback: (notification: TdSchemaNotification) => void): void;
-    onConfigChanged(callback: (config: TdSiteConfig) => void): void;
-}