kkrpc 0.2.0 → 0.2.1

package/README.md

@@ -1,5 +1,9 @@
 # kkrpc
 
+> This project is created for building extension system for a Tauri app (https://github.com/kunkunsh/kunkun).
+>
+> It's potential can be used in other types of apps, so I open sourced it as a standalone package.
+
 [![NPM Version](https://img.shields.io/npm/v/kkrpc)](https://www.npmjs.com/package/kkrpc)
 [![JSR Version](https://jsr.io/badges/@kunkun/kkrpc)](https://jsr.io/@kunkun/kkrpc)
 ![GitHub last commit](https://img.shields.io/github/last-commit/kunkunsh/kkrpc)
@@ -12,11 +16,12 @@
 - [Documentation by JSR](https://jsr.io/@kunkun/kkrpc/doc)
 - [Typedoc Documentation](https://kunkunsh.github.io/kkrpc/)
 
-[Excalidraw Diagrams](https://excalidraw.com/#json=otqFU25B2sSjweA4Sbq9l,7-eY_bzFrGAXLNkOVpQ2Tg)
+[Excalidraw Diagrams](https://excalidraw.com/#json=xp6GbAJVAx3nU-h3PhaxW,oYBNvYmCRsQ2XR3MQo73Ug)
 
-![](https://imgur.com/vR3Lmv0.png)
-![](https://imgur.com/u728aVv.png)
-![](https://imgur.com/2ycWgVQ.png)
+<img src="https://imgur.com/vR3Lmv0.png" style="max-height: 200px;"/>
+<img src="https://i.imgur.com/zmOHNfu.png" style="max-height: 250px;"/>
+<img src="https://imgur.com/u728aVv.png" style="max-height: 400px;"/>
+<img src="https://i.imgur.com/Gu7jH1v.png" style="max-height: 300px;"/>
 
 ## Supported Environments
 
@@ -225,6 +230,10 @@ console.log(data) // { message: "Hello from background!" }
 
 Call functions in bun/node/deno processes from Tauri app with JS/TS.
 
+It allows you to call any JS/TS code in Deno/Bun/Node processes from Tauri app, just like using Electron.
+
+Seamless integration with Tauri's official shell plugin and [unlocked shellx plugin](https://github.com/HuakunShen/tauri-plugin-shellx).
+
 ```ts
 import { RPCChannel, TauriShellStdio } from "kkrpc/browser"
 import { Child, Command } from "@tauri-apps/plugin-shell"
@@ -250,6 +259,7 @@ async function spawnCmd(runtime: "deno" | "bun" | "node") {
 		throw new Error(`Invalid runtime: ${runtime}, pick either deno or bun`)
 	}
 
+	// monitor stdout/stderr/close/error for debugging and error handling
 	cmd.stdout.on("data", (data) => {
 		console.log("stdout", data)
 	})
@@ -281,3 +291,7 @@ async function spawnCmd(runtime: "deno" | "bun" | "node") {
 	process?.kill()
 }
 ```
+
+I provided a sample tauri app in `examples/tauri-demo`.
+
+![Sample Tauri App](https://i.imgur.com/nkDwRHk.png)

package/dist/chunk-GRCUBSPR.js

@@ -0,0 +1,27 @@
+// src/adapters/deno.ts
+import { Buffer } from "node:buffer";
+var DenoIo = class {
+  constructor(readStream) {
+    this.readStream = readStream;
+    this.reader = this.readStream.getReader();
+  }
+  reader;
+  name = "deno-io";
+  async read() {
+    const { value, done } = await this.reader.read();
+    if (done) {
+      return null;
+    }
+    return Buffer.from(value);
+  }
+  write(data) {
+    const encoder = new TextEncoder();
+    const encodedData = encoder.encode(data + "\n");
+    Deno.stdout.writeSync(encodedData);
+    return Promise.resolve();
+  }
+};
+
+export {
+  DenoIo
+};

package/dist/deno-mod.cjs

@@ -0,0 +1,355 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// deno-mod.ts
+var deno_mod_exports = {};
+__export(deno_mod_exports, {
+  DenoIo: () => DenoIo,
+  RPCChannel: () => RPCChannel
+});
+module.exports = __toCommonJS(deno_mod_exports);
+
+// src/adapters/deno.ts
+var import_node_buffer = require("buffer");
+var DenoIo = class {
+  constructor(readStream) {
+    this.readStream = readStream;
+    this.reader = this.readStream.getReader();
+  }
+  reader;
+  name = "deno-io";
+  async read() {
+    const { value, done } = await this.reader.read();
+    if (done) {
+      return null;
+    }
+    return import_node_buffer.Buffer.from(value);
+  }
+  write(data) {
+    const encoder = new TextEncoder();
+    const encodedData = encoder.encode(data + "\n");
+    Deno.stdout.writeSync(encodedData);
+    return Promise.resolve();
+  }
+};
+
+// src/serialization.ts
+var import_superjson = __toESM(require("superjson"), 1);
+function serializeMessage(message) {
+  return import_superjson.default.stringify(message) + "\n";
+}
+function deserializeMessage(message) {
+  return new Promise((resolve, reject) => {
+    try {
+      const parsed = import_superjson.default.parse(message);
+      resolve(parsed);
+    } catch (error) {
+      console.error("failed to parse message", typeof message, message, error);
+      reject(error);
+    }
+  });
+}
+
+// src/utils.ts
+function generateUUID() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+
+// src/channel.ts
+var RPCChannel = class {
+  constructor(io, options) {
+    this.io = io;
+    this.apiImplementation = options?.expose;
+    this.listen();
+  }
+  pendingRequests = {};
+  callbacks = {};
+  callbackCache = /* @__PURE__ */ new Map();
+  count = 0;
+  messageStr = "";
+  apiImplementation;
+  /**
+   * Exposes a local API implementation that can be called remotely
+   * @param api The local API implementation to expose
+   */
+  expose(api) {
+    this.apiImplementation = api;
+  }
+  /**
+   * Returns the IO interface used by this channel
+   * @returns The IO interface instance
+   */
+  getIO() {
+    return this.io;
+  }
+  /**
+   * Listens for incoming messages on the IO interface
+   * Handles message buffering and parsing
+   * @private
+   */
+  async listen() {
+    while (true) {
+      const buffer = await this.io.read();
+      if (!buffer) {
+        continue;
+      }
+      const bufferStr = buffer.toString("utf-8");
+      if (bufferStr.trim().length === 0) {
+        continue;
+      }
+      this.messageStr += bufferStr;
+      const lastChar = this.messageStr[this.messageStr.length - 1];
+      const msgsSplit = this.messageStr.split("\n");
+      const msgs = lastChar === "\n" ? msgsSplit : msgsSplit.slice(0, -1);
+      this.messageStr = lastChar === "\n" ? "" : msgsSplit.at(-1) ?? "";
+      for (const msgStr of msgs.map((msg) => msg.trim()).filter(Boolean)) {
+        if (msgStr.startsWith("{")) {
+          this.handleMessageStr(msgStr);
+        } else {
+          console.log(`(kkrpc stdout passthrough):`, msgStr);
+        }
+      }
+    }
+  }
+  /**
+   * Handles a single message string by parsing and routing it
+   * @param messageStr The message string to handle
+   * @private 
+   */
+  async handleMessageStr(messageStr) {
+    this.count++;
+    return deserializeMessage(messageStr).then((parsedMessage) => {
+      if (parsedMessage.type === "response") {
+        this.handleResponse(parsedMessage);
+      } else if (parsedMessage.type === "request") {
+        this.handleRequest(parsedMessage);
+      } else if (parsedMessage.type === "callback") {
+        this.handleCallback(parsedMessage);
+      } else {
+        console.error("received unknown message type", parsedMessage, typeof parsedMessage);
+      }
+    }).catch((err) => {
+      console.log(`(kkrpc stdout passthrough):`, messageStr);
+    });
+  }
+  /**
+   * Calls a method on the remote API
+   * @param method The name of the method to call
+   * @param args Arguments to pass to the remote method
+   * @returns Promise that resolves with the result of the remote call
+   */
+  callMethod(method, args) {
+    return new Promise((resolve, reject) => {
+      const messageId = generateUUID();
+      this.pendingRequests[messageId] = { resolve, reject };
+      const callbackIds = [];
+      const processedArgs = args.map((arg) => {
+        if (typeof arg === "function") {
+          let callbackId = this.callbackCache.get(arg);
+          if (!callbackId) {
+            callbackId = generateUUID();
+            this.callbacks[callbackId] = arg;
+            this.callbackCache.set(arg, callbackId);
+          } else {
+          }
+          callbackIds.push(callbackId);
+          return `__callback__${callbackId}`;
+        }
+        return arg;
+      });
+      const message = {
+        id: messageId,
+        method,
+        args: processedArgs,
+        type: "request",
+        callbackIds: callbackIds.length > 0 ? callbackIds : void 0
+      };
+      this.io.write(serializeMessage(message));
+    });
+  }
+  /**
+   * Handles responses received from remote method calls
+   * @param response The response message to handle
+   * @private
+   */
+  handleResponse(response) {
+    const { id } = response;
+    const { result, error } = response.args;
+    if (this.pendingRequests[id]) {
+      if (error) {
+        this.pendingRequests[id].reject(new Error(error));
+      } else {
+        this.pendingRequests[id].resolve(result);
+      }
+      delete this.pendingRequests[id];
+    }
+  }
+  /**
+   * Handles incoming method call requests from the remote endpoint
+   * @param request The request message to handle
+   * @private
+   */
+  handleRequest(request) {
+    const { id, method, args } = request;
+    const methodPath = method.split(".");
+    if (!this.apiImplementation) return;
+    let target = this.apiImplementation;
+    for (let i = 0; i < methodPath.length - 1; i++) {
+      target = target[methodPath[i]];
+      if (!target) {
+        this.sendError(id, `Method path ${method} not found at ${methodPath[i]}`);
+        return;
+      }
+    }
+    const finalMethod = methodPath[methodPath.length - 1];
+    const targetMethod = target[finalMethod];
+    if (typeof targetMethod !== "function") {
+      this.sendError(id, `Method ${method} is not a function`);
+      return;
+    }
+    const processedArgs = args.map((arg) => {
+      if (typeof arg === "string" && arg.startsWith("__callback__")) {
+        const callbackId = arg.slice(12);
+        return (...callbackArgs) => {
+          this.invokeCallback(callbackId, callbackArgs);
+        };
+      }
+      return arg;
+    });
+    try {
+      const result = targetMethod.apply(target, processedArgs);
+      Promise.resolve(result).then((res) => {
+        return this.sendResponse(id, res);
+      }).catch((err) => this.sendError(id, err.message));
+    } catch (error) {
+      this.sendError(id, error.message ?? error.toString());
+    }
+  }
+  /**
+   * Invokes a callback on the remote endpoint
+   * @param callbackId The ID of the callback to invoke
+   * @param args Arguments to pass to the callback
+   * @private
+   */
+  invokeCallback(callbackId, args) {
+    const message = {
+      id: generateUUID(),
+      method: callbackId,
+      args,
+      type: "callback"
+    };
+    this.io.write(serializeMessage(message));
+  }
+  /**
+   * Handles callback invocations received from the remote endpoint
+   * @param message The callback message to handle
+   * @private
+   */
+  handleCallback(message) {
+    const { method: callbackId, args } = message;
+    const callback = this.callbacks[callbackId];
+    if (callback) {
+      callback(...args);
+    } else {
+      console.error(`Callback with id ${callbackId} not found`);
+    }
+  }
+  /**
+   * Sends a successful response back to the remote endpoint
+   * @param id The ID of the request being responded to
+   * @param result The result to send back
+   * @private
+   */
+  sendResponse(id, result) {
+    const response = {
+      id,
+      method: "",
+      args: { result },
+      type: "response"
+    };
+    this.io.write(serializeMessage(response));
+  }
+  /**
+   * Sends an error response back to the remote endpoint
+   * @param id The ID of the request being responded to
+   * @param error The error message to send back
+   * @private
+   */
+  sendError(id, error) {
+    const response = {
+      id,
+      method: "",
+      args: { error },
+      type: "response"
+    };
+    this.io.write(serializeMessage(response));
+  }
+  /**
+   * Creates a nested proxy object for chaining remote method calls
+   * @param chain Array of method names in the chain
+   * @returns Proxy object that transforms property access into remote method calls
+   * @private
+   */
+  createNestedProxy(chain = []) {
+    return new Proxy(() => {
+    }, {
+      get: (_target, prop) => {
+        if (typeof prop === "string" && prop !== "then") {
+          return this.createNestedProxy([...chain, prop]);
+        }
+        return void 0;
+      },
+      apply: (_target, _thisArg, args) => {
+        const method = chain.join(".");
+        return this.callMethod(method, args);
+      }
+    });
+  }
+  /**
+   * Returns a proxy object that represents the remote API
+   * Methods called on this proxy will be executed on the remote endpoint
+   * @returns Proxy object representing the remote API
+   */
+  getAPI() {
+    return this.createNestedProxy();
+  }
+  /**
+   * Frees up memory by clearing stored callbacks and callback cache
+   * Useful when dealing with many anonymous callback functions to prevent memory leaks
+   */
+  freeCallbacks() {
+    this.callbacks = {};
+    this.callbackCache.clear();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DenoIo,
+  RPCChannel
+});

package/dist/deno-mod.d.cts

@@ -0,0 +1,19 @@
+import { Buffer } from 'node:buffer';
+import { I as IoInterface } from './channel-D6ZClufP.cjs';
+export { R as RPCChannel } from './channel-D6ZClufP.cjs';
+
+/**
+ * Stdio implementation for Deno
+ * Deno doesn't have `process` object, and have a completely different stdio API,
+ * This implementation wrap Deno's `Deno.stdin` and `Deno.stdout` to follow StdioInterface
+ */
+declare class DenoIo implements IoInterface {
+    private readStream;
+    private reader;
+    name: string;
+    constructor(readStream: ReadableStream<Uint8Array>);
+    read(): Promise<Buffer | null>;
+    write(data: string): Promise<void>;
+}
+
+export { DenoIo };

package/dist/deno-mod.d.ts

@@ -0,0 +1,19 @@
+import { Buffer } from 'node:buffer';
+import { I as IoInterface } from './channel-D6ZClufP.js';
+export { R as RPCChannel } from './channel-D6ZClufP.js';
+
+/**
+ * Stdio implementation for Deno
+ * Deno doesn't have `process` object, and have a completely different stdio API,
+ * This implementation wrap Deno's `Deno.stdin` and `Deno.stdout` to follow StdioInterface
+ */
+declare class DenoIo implements IoInterface {
+    private readStream;
+    private reader;
+    name: string;
+    constructor(readStream: ReadableStream<Uint8Array>);
+    read(): Promise<Buffer | null>;
+    write(data: string): Promise<void>;
+}
+
+export { DenoIo };

package/dist/deno-mod.js

@@ -0,0 +1,10 @@
+import {
+  DenoIo
+} from "./chunk-GRCUBSPR.js";
+import {
+  RPCChannel
+} from "./chunk-ZSSFWNSX.js";
+export {
+  DenoIo,
+  RPCChannel
+};

package/dist/mod.d.cts

@@ -5,6 +5,7 @@ import { I as IoInterface, D as DestroyableIoInterface } from './channel-D6ZCluf
 export { R as RPCChannel } from './channel-D6ZClufP.cjs';
 import { Readable, Writable } from 'node:stream';
 export { H as HTTPClientIO, a as HTTPServerIO } from './http-CvGfNM3D.cjs';
+export { DenoIo } from './deno-mod.cjs';
 import '@tauri-apps/plugin-shell';
 
 /**
@@ -80,18 +81,4 @@ declare class WebSocketServerIO implements DestroyableIoInterface {
     signalDestroy(): void;
 }
 
-/**
- * Stdio implementation for Deno
- * Deno doesn't have `process` object, and have a completely different stdio API,
- * This implementation wrap Deno's `Deno.stdin` and `Deno.stdout` to follow StdioInterface
- */
-declare class DenoIo implements IoInterface {
-    private readStream;
-    private reader;
-    name: string;
-    constructor(readStream: ReadableStream<Uint8Array>);
-    read(): Promise<Buffer | null>;
-    write(data: string): Promise<void>;
-}
-
-export { BunIo, DenoIo, DestroyableIoInterface, IoInterface, NodeIo, WebSocketClientIO, WebSocketServerIO };
+export { BunIo, DestroyableIoInterface, IoInterface, NodeIo, WebSocketClientIO, WebSocketServerIO };

package/dist/mod.d.ts

@@ -5,6 +5,7 @@ import { I as IoInterface, D as DestroyableIoInterface } from './channel-D6ZCluf
 export { R as RPCChannel } from './channel-D6ZClufP.js';
 import { Readable, Writable } from 'node:stream';
 export { H as HTTPClientIO, a as HTTPServerIO } from './http-Bz7mwStC.js';
+export { DenoIo } from './deno-mod.js';
 import '@tauri-apps/plugin-shell';
 
 /**
@@ -80,18 +81,4 @@ declare class WebSocketServerIO implements DestroyableIoInterface {
     signalDestroy(): void;
 }
 
-/**
- * Stdio implementation for Deno
- * Deno doesn't have `process` object, and have a completely different stdio API,
- * This implementation wrap Deno's `Deno.stdin` and `Deno.stdout` to follow StdioInterface
- */
-declare class DenoIo implements IoInterface {
-    private readStream;
-    private reader;
-    name: string;
-    constructor(readStream: ReadableStream<Uint8Array>);
-    read(): Promise<Buffer | null>;
-    write(data: string): Promise<void>;
-}
-
-export { BunIo, DenoIo, DestroyableIoInterface, IoInterface, NodeIo, WebSocketClientIO, WebSocketServerIO };
+export { BunIo, DestroyableIoInterface, IoInterface, NodeIo, WebSocketClientIO, WebSocketServerIO };

package/dist/mod.js

@@ -7,6 +7,9 @@ import {
   ChromeBackgroundIO,
   ChromeContentIO
 } from "./chunk-INKNKSKA.js";
+import {
+  DenoIo
+} from "./chunk-GRCUBSPR.js";
 import {
   HTTPClientIO,
   HTTPServerIO
@@ -188,30 +191,6 @@ var WebSocketServerIO = class {
     this.write(DESTROY_SIGNAL);
   }
 };
-
-// src/adapters/deno.ts
-import { Buffer as Buffer2 } from "node:buffer";
-var DenoIo = class {
-  constructor(readStream) {
-    this.readStream = readStream;
-    this.reader = this.readStream.getReader();
-  }
-  reader;
-  name = "deno-io";
-  async read() {
-    const { value, done } = await this.reader.read();
-    if (done) {
-      return null;
-    }
-    return Buffer2.from(value);
-  }
-  write(data) {
-    const encoder = new TextEncoder();
-    const encodedData = encoder.encode(data + "\n");
-    Deno.stdout.writeSync(encodedData);
-    return Promise.resolve();
-  }
-};
 export {
   BunIo,
   ChromeBackgroundIO,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "kkrpc",
-	"version": "0.2.0",
+	"version": "0.2.1",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -43,6 +43,15 @@
 			"import": "./dist/http.js",
 			"require": "./dist/http.cjs"
 		},
+		"./deno": {
+			"types": {
+				"import": "./dist/deno-mod.d.ts",
+				"require": "./dist/deno-mod.cjs",
+				"default": "./dist/deno-mod.js"
+			},
+			"import": "./dist/deno-mod.js",
+			"require": "./dist/deno-mod.cjs"
+		},
 		"./chrome": {
 			"types": {
 				"import": "./dist/chrome.d.ts",