@qping/plugin-bus 0.1.0 → 0.2.0

package/dist/protocol.mjs

@@ -1,4 +1,68 @@
 // src/protocol.ts
+var MessageKind = {
+  Request: "request",
+  Response: "response",
+  Event: "event"
+};
+var ErrorCode = {
+  ProtocolMismatch: "ProtocolMismatch",
+  HandshakeFailed: "HandshakeFailed",
+  CapabilityNotDeclared: "CapabilityNotDeclared",
+  CapabilityDenied: "CapabilityDenied",
+  InvalidPayload: "InvalidPayload",
+  MessageTooLarge: "MessageTooLarge",
+  RouteNotFound: "RouteNotFound",
+  RequestTimeout: "RequestTimeout",
+  TooManyRequests: "TooManyRequests",
+  TransportDisconnected: "TransportDisconnected",
+  PluginUnavailable: "PluginUnavailable",
+  InternalError: "InternalError",
+  Cancelled: "Cancelled",
+  RateLimited: "RateLimited"
+};
+var ProtocolVersion = "3.0";
+var EndpointIds = {
+  NodeMain: "node-main",
+  Host: "host"
+};
+var Routes = {
+  Bus: {
+    Handshake: "bus.handshake",
+    Ping: "bus.ping",
+    Cancel: "bus.cancel",
+    Subscribe: "bus.subscribe",
+    Unsubscribe: "bus.unsubscribe"
+  },
+  Prefix: {
+    PluginCall: "plugin.call.",
+    HostCall: "host.call.",
+    PluginEvent: "plugin.event.",
+    HostEvent: "host.event.",
+    Diagnostics: "diagnostics."
+  },
+  PluginCall: {
+    Initialize: "plugin.call.initialize",
+    Search: "plugin.call.search",
+    InvokeAction: "plugin.call.invokeAction"
+  },
+  HostEvent: {
+    Initialize: "host.event.initialize",
+    Search: "host.event.search",
+    Key: "host.event.key",
+    LanguageChanged: "host.event.languageChanged",
+    ThemeChanged: "host.event.themeChanged",
+    InputActionCaptured: "host.event.inputActionCaptured"
+  }
+};
+function pluginCallRoute(method) {
+  return method.startsWith(Routes.Prefix.PluginCall) ? method : `${Routes.Prefix.PluginCall}${method}`;
+}
+function hostCallRoute(method) {
+  return method.startsWith(Routes.Prefix.HostCall) ? method : `${Routes.Prefix.HostCall}${method}`;
+}
+function pluginEventRoute(subjectId) {
+  return subjectId.startsWith(Routes.Prefix.PluginEvent) ? subjectId : `${Routes.Prefix.PluginEvent}${subjectId}`;
+}
 function canonicalStringify(value) {
   return JSON.stringify(stripNulls(value));
 }
@@ -19,6 +83,14 @@ function canonicalize(json) {
   return canonicalStringify(JSON.parse(json));
 }
 export {
+  EndpointIds,
+  ErrorCode,
+  MessageKind,
+  ProtocolVersion,
+  Routes,
   canonicalStringify,
-  canonicalize
+  canonicalize,
+  hostCallRoute,
+  pluginCallRoute,
+  pluginEventRoute
 };

package/dist/router.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Handler router for the Node SDK v3. Dispatches inbound plugin.call.* requests to registered
+ * handlers, auto-replies to bus.ping, and provides callHost() to invoke host.call.* capabilities
+ * and correlate their responses. Mirrors the C# MessageBus routing rules on the Node side.
+ */
+import { type Envelope } from "./protocol.ts";
+type Handler = (payload: unknown) => Promise<unknown> | unknown;
+type Sender = (env: Envelope) => void;
+export declare const DefaultHostCallTimeoutMs = 30000;
+/** Remaining ms of the inbound plugin.call timeout, if currently inside a request. */
+export declare function remainingTimeoutMs(): number | undefined;
+export declare function resolveHostCallTimeoutMs(explicit?: number): number;
+export declare class HandlerRouter {
+    private handlers;
+    private pendingHostCalls;
+    private pluginId;
+    private entryId;
+    private sessionId;
+    private endpointId;
+    /** Injected transport send fn; tests can override `router.send` directly. */
+    send: Sender;
+    constructor(deps: {
+        send: Sender;
+    });
+    /** Sets the bound identity stamped on outbound messages (after handshake). */
+    setIdentity(ids: {
+        pluginId: string;
+        entryId: string;
+        sessionId: string;
+        endpointId: string;
+    }): void;
+    handle(route: string, handler: Handler): void;
+    /** Dispatches an inbound request/response. Returns once handled. */
+    dispatch(env: Envelope): Promise<void>;
+    /** Calls a host.call.* capability and resolves with the response payload. */
+    callHost(route: string, payload: unknown, timeoutMs?: number): Promise<unknown>;
+    private handleHostResponse;
+    private responseFor;
+    private errorResponseFor;
+}
+export {};

package/dist/transport.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Node-side named-pipe transport for the v3 message bus. Connects to the host's pipe server
+ * (created by NamedPipeTransport on the C# side), runs an incremental FrameDecoder read loop,
+ * and sends length-prefixed frames. Mirrors MyTools.Host.Transports.NamedPipeTransport.
+ */
+import { type Envelope } from "./protocol.ts";
+type MessageHandler = (env: Envelope) => void;
+type DisconnectHandler = () => void;
+export declare class NodeTransport {
+    private socket;
+    private messageHandlers;
+    private disconnectHandlers;
+    private closed;
+    onMessage(handler: MessageHandler): () => void;
+    onDisconnect(handler: DisconnectHandler): void;
+    get isConnected(): boolean;
+    /** Connects to a Windows named pipe (\\.\pipe\<name>). */
+    connect(pipePath: string): Promise<void>;
+    /** Serializes an envelope to a length-prefixed frame and writes it. */
+    send(env: Envelope): void;
+    close(): Promise<void>;
+    private handleDisconnect;
+}
+export {};

package/dist/webClient.d.ts

@@ -0,0 +1,34 @@
+/**
+ * v3 Web SDK: speaks protocol envelopes over chrome.webview.postMessage.
+ * Host stamps identity; the page does not supply plugin/entry/session ids.
+ *
+ * Connections start with bus.handshake. Subsequent plugin.call.* envelopes use the
+ * negotiated version. call("refresh") is sent as plugin.call.refresh.
+ */
+import { mytoolsI18n } from "./i18n.ts";
+import type { MyToolsThemePayload } from "./webTypes.ts";
+export { mytoolsI18n } from "./i18n.ts";
+export { HostEvents } from "./webTypes.ts";
+export type { MyToolsHostInitializePayload, MyToolsHostKeyPayload, MyToolsHostSearchPayload, MyToolsInputActionCapturedPayload, MyToolsLanguageChangedPayload, MyToolsThemeChangedPayload, MyToolsThemePayload, } from "./webTypes.ts";
+export interface WebBusClient {
+    /** Sends plugin.call.<method>. Bare names are prefixed; full routes are left as-is. */
+    call<T = unknown>(method: string, payload?: unknown, timeoutMs?: number): Promise<T>;
+    on<T = unknown>(route: string, handler: (payload: T) => void): () => void;
+    i18n: typeof mytoolsI18n;
+    theme: typeof mytoolsTheme;
+    close(): void;
+}
+declare const mytoolsTheme: {
+    current: string;
+    apply(payload: MyToolsThemePayload): void;
+};
+/**
+ * Creates a Web bus client. Registers the message listener immediately so host
+ * events that arrive before `on()` are buffered and replayed.
+ *
+ * Handshake is required before call(). Page scripts are bundled as IIFE, so this
+ * function is synchronous; handshake runs in the background and gates call().
+ */
+export declare function createWebBusClient(options?: {
+    timeoutMs?: number;
+}): WebBusClient;