kkrpc 0.2.0-beta.2 → 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
 
@@ -220,3 +225,73 @@ const api = rpc.getAPI()
 const data = await api.getData()
 console.log(data) // { message: "Hello from background!" }
 ```
+
+### Tauri Example
+
+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"
+
+const localAPIImplementation = {
+	add: (a: number, b: number) => Promise.resolve(a + b)
+}
+
+async function spawnCmd(runtime: "deno" | "bun" | "node") {
+	let cmd: Command<string>
+	let process = Child | null = null
+
+	if (runtime === "deno") {
+		cmd = Command.create("deno", ["run", "-A", scriptPath])
+		process = await cmd.spawn()
+	} else if (runtime === "bun") {
+		cmd = Command.create("bun", [scriptPath])
+		process = await cmd.spawn()
+	} else if (runtime === "node") {
+		cmd = Command.create("node", [scriptPath])
+		process = await cmd.spawn()
+	} else {
+		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)
+	})
+	cmd.stderr.on("data", (data) => {
+		console.warn("stderr", data)
+	})
+	cmd.on("close", (code) => {
+		console.log("close", code)
+	})
+	cmd.on("error", (err) => {
+		console.error("error", err)
+	})
+
+	const stdio = new TauriShellStdio(cmd.stdout, process)
+	const stdioRPC = new RPCChannel<typeof localAPIImplementation, RemoteAPI>(stdio, {
+		expose: localAPIImplementation
+	})
+
+	const api = stdioRPC.getAPI();
+	await api
+		.add(1, 2)
+		.then((result) => {
+			console.log("result", result)
+		})
+		.catch((err) => {
+			console.error(err)
+		})
+
+	process?.kill()
+}
+```
+
+I provided a sample tauri app in `examples/tauri-demo`.
+
+![Sample Tauri App](https://i.imgur.com/nkDwRHk.png)

package/dist/browser-mod.cjs

@@ -35,6 +35,7 @@ __export(browser_mod_exports, {
   IframeChildIO: () => IframeChildIO,
   IframeParentIO: () => IframeParentIO,
   RPCChannel: () => RPCChannel,
+  TauriShellStdio: () => TauriShellStdio,
   WorkerChildIO: () => WorkerChildIO,
   WorkerParentIO: () => WorkerParentIO,
   deserializeMessage: () => deserializeMessage,
@@ -343,6 +344,26 @@ var IframeChildIO = class {
   }
 };
 
+// src/adapters/tauri.ts
+var import_plugin_shell = require("@tauri-apps/plugin-shell");
+var TauriShellStdio = class {
+  constructor(readStream, childProcess) {
+    this.readStream = readStream;
+    this.childProcess = childProcess;
+  }
+  name = "tauri-shell-stdio";
+  read() {
+    return new Promise((resolve, reject) => {
+      this.readStream.on("data", (chunk) => {
+        resolve(chunk);
+      });
+    });
+  }
+  async write(data) {
+    return this.childProcess.write(data + "\n");
+  }
+};
+
 // src/interface.ts
 var import_node_buffer = require("buffer");
 
@@ -656,6 +677,7 @@ var RPCChannel = class {
   IframeChildIO,
   IframeParentIO,
   RPCChannel,
+  TauriShellStdio,
   WorkerChildIO,
   WorkerParentIO,
   deserializeMessage,

package/dist/browser-mod.d.cts

@@ -1,7 +1,8 @@
-export { a as WorkerChildIO, W as WorkerParentIO } from './worker-72MNjMgj.cjs';
+export { T as TauriShellStdio, a as WorkerChildIO, W as WorkerParentIO } from './tauri-CRNRbu3f.cjs';
 export { ChromeBackgroundIO, ChromeContentIO, Message, Response, deserializeMessage, deserializeResponse, generateUUID, serializeMessage, serializeResponse } from './chrome.cjs';
 import { D as DestroyableIoInterface } from './channel-D6ZClufP.cjs';
 export { I as IoInterface, R as RPCChannel } from './channel-D6ZClufP.cjs';
+import '@tauri-apps/plugin-shell';
 import 'node:buffer';
 
 /**

package/dist/browser-mod.d.ts

@@ -1,7 +1,8 @@
-export { a as WorkerChildIO, W as WorkerParentIO } from './worker-DiYJxxHW.js';
+export { T as TauriShellStdio, a as WorkerChildIO, W as WorkerParentIO } from './tauri-PdcZTVUI.js';
 export { ChromeBackgroundIO, ChromeContentIO, Message, Response, deserializeMessage, deserializeResponse, generateUUID, serializeMessage, serializeResponse } from './chrome.js';
 import { D as DestroyableIoInterface } from './channel-D6ZClufP.js';
 export { I as IoInterface, R as RPCChannel } from './channel-D6ZClufP.js';
+import '@tauri-apps/plugin-shell';
 import 'node:buffer';
 
 /**

package/dist/browser-mod.js

@@ -1,7 +1,8 @@
 import {
+  TauriShellStdio,
   WorkerChildIO,
   WorkerParentIO
-} from "./chunk-XU7DWWSJ.js";
+} from "./chunk-KZFPA2BM.js";
 import {
   ChromeBackgroundIO,
   ChromeContentIO
@@ -154,6 +155,7 @@ export {
   IframeChildIO,
   IframeParentIO,
   RPCChannel,
+  TauriShellStdio,
   WorkerChildIO,
   WorkerParentIO,
   deserializeMessage,

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/{chunk-XU7DWWSJ.js → chunk-KZFPA2BM.js}

@@ -82,7 +82,28 @@ var WorkerChildIO = class {
   }
 };
 
+// src/adapters/tauri.ts
+import "@tauri-apps/plugin-shell";
+var TauriShellStdio = class {
+  constructor(readStream, childProcess) {
+    this.readStream = readStream;
+    this.childProcess = childProcess;
+  }
+  name = "tauri-shell-stdio";
+  read() {
+    return new Promise((resolve, reject) => {
+      this.readStream.on("data", (chunk) => {
+        resolve(chunk);
+      });
+    });
+  }
+  async write(data) {
+    return this.childProcess.write(data + "\n");
+  }
+};
+
 export {
   WorkerParentIO,
-  WorkerChildIO
+  WorkerChildIO,
+  TauriShellStdio
 };

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.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // mod.ts
 var mod_exports = {};
 __export(mod_exports, {
+  BunIo: () => BunIo,
   ChromeBackgroundIO: () => ChromeBackgroundIO,
   ChromeContentIO: () => ChromeContentIO,
   DenoIo: () => DenoIo,
@@ -37,6 +38,7 @@ __export(mod_exports, {
   HTTPServerIO: () => HTTPServerIO,
   NodeIo: () => NodeIo,
   RPCChannel: () => RPCChannel,
+  TauriShellStdio: () => TauriShellStdio,
   WebSocketClientIO: () => WebSocketClientIO,
   WebSocketServerIO: () => WebSocketServerIO,
   WorkerChildIO: () => WorkerChildIO,
@@ -213,14 +215,36 @@ var ChromeContentIO = class {
   }
 };
 
-// src/adapters/node.ts
+// src/adapters/bun.ts
 var import_node_buffer2 = require("buffer");
-var import_node_stream = require("stream");
 
 // src/interface.ts
 var import_node_buffer = require("buffer");
 
+// src/adapters/bun.ts
+var BunIo = class {
+  name = "bun-io";
+  readStream;
+  reader;
+  constructor(readStream) {
+    this.readStream = readStream;
+    this.reader = this.readStream.getReader();
+  }
+  async read() {
+    const { value, done } = await this.reader.read();
+    if (done) {
+      return null;
+    }
+    return import_node_buffer2.Buffer.from(value);
+  }
+  async write(data) {
+    return Bun.write(Bun.stdout, data).then(() => Promise.resolve());
+  }
+};
+
 // src/adapters/node.ts
+var import_node_buffer3 = require("buffer");
+var import_node_stream = require("stream");
 var NodeIo = class {
   name = "node-io";
   readStream;
@@ -457,6 +481,26 @@ var HTTPServerIO = class {
   }
 };
 
+// src/adapters/tauri.ts
+var import_plugin_shell = require("@tauri-apps/plugin-shell");
+var TauriShellStdio = class {
+  constructor(readStream, childProcess) {
+    this.readStream = readStream;
+    this.childProcess = childProcess;
+  }
+  name = "tauri-shell-stdio";
+  read() {
+    return new Promise((resolve, reject) => {
+      this.readStream.on("data", (chunk) => {
+        resolve(chunk);
+      });
+    });
+  }
+  async write(data) {
+    return this.childProcess.write(data + "\n");
+  }
+};
+
 // src/serialization.ts
 var import_superjson2 = __toESM(require("superjson"), 1);
 function serializeMessage(message) {
@@ -762,11 +806,10 @@ var RPCChannel = class {
 };
 
 // src/adapters/deno.ts
-var import_node_buffer3 = require("buffer");
+var import_node_buffer4 = require("buffer");
 var DenoIo = class {
-  constructor(readStream, writeStream) {
+  constructor(readStream) {
     this.readStream = readStream;
-    this.writeStream = writeStream;
     this.reader = this.readStream.getReader();
   }
   reader;
@@ -776,7 +819,7 @@ var DenoIo = class {
     if (done) {
       return null;
     }
-    return import_node_buffer3.Buffer.from(value);
+    return import_node_buffer4.Buffer.from(value);
   }
   write(data) {
     const encoder = new TextEncoder();
@@ -787,6 +830,7 @@ var DenoIo = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BunIo,
   ChromeBackgroundIO,
   ChromeContentIO,
   DenoIo,
@@ -794,6 +838,7 @@ var DenoIo = class {
   HTTPServerIO,
   NodeIo,
   RPCChannel,
+  TauriShellStdio,
   WebSocketClientIO,
   WebSocketServerIO,
   WorkerChildIO,

package/dist/mod.d.cts

@@ -1,10 +1,29 @@
-export { a as WorkerChildIO, W as WorkerParentIO } from './worker-72MNjMgj.cjs';
+export { T as TauriShellStdio, a as WorkerChildIO, W as WorkerParentIO } from './tauri-CRNRbu3f.cjs';
 export { ChromeBackgroundIO, ChromeContentIO, Message, Response, deserializeMessage, deserializeResponse, generateUUID, serializeMessage, serializeResponse } from './chrome.cjs';
 import { Buffer } from 'node:buffer';
-import { Readable, Writable } from 'node:stream';
 import { I as IoInterface, D as DestroyableIoInterface } from './channel-D6ZClufP.cjs';
 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';
+
+/**
+ * Node.js implementation of IoInterface
+ * Should also work with Bun
+ */
+
+/**
+ * Stdio implementation for Bun
+ */
+declare class BunIo implements IoInterface {
+    name: string;
+    private readStream;
+    private reader;
+    constructor(readStream: ReadableStream<Uint8Array>);
+    read(): Promise<Buffer | null>;
+    write(data: string): Promise<void>;
+}
 
 /**
  * Node.js implementation of IoInterface
@@ -62,19 +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 writeStream;
-    private reader;
-    name: string;
-    constructor(readStream: ReadableStream<Uint8Array>, writeStream: WritableStream<Uint8Array>);
-    read(): Promise<Buffer | null>;
-    write(data: string): Promise<void>;
-}
-
-export { DenoIo, DestroyableIoInterface, IoInterface, NodeIo, WebSocketClientIO, WebSocketServerIO };
+export { BunIo, DestroyableIoInterface, IoInterface, NodeIo, WebSocketClientIO, WebSocketServerIO };

package/dist/mod.d.ts

@@ -1,10 +1,29 @@
-export { a as WorkerChildIO, W as WorkerParentIO } from './worker-DiYJxxHW.js';
+export { T as TauriShellStdio, a as WorkerChildIO, W as WorkerParentIO } from './tauri-PdcZTVUI.js';
 export { ChromeBackgroundIO, ChromeContentIO, Message, Response, deserializeMessage, deserializeResponse, generateUUID, serializeMessage, serializeResponse } from './chrome.js';
 import { Buffer } from 'node:buffer';
-import { Readable, Writable } from 'node:stream';
 import { I as IoInterface, D as DestroyableIoInterface } from './channel-D6ZClufP.js';
 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';
+
+/**
+ * Node.js implementation of IoInterface
+ * Should also work with Bun
+ */
+
+/**
+ * Stdio implementation for Bun
+ */
+declare class BunIo implements IoInterface {
+    name: string;
+    private readStream;
+    private reader;
+    constructor(readStream: ReadableStream<Uint8Array>);
+    read(): Promise<Buffer | null>;
+    write(data: string): Promise<void>;
+}
 
 /**
  * Node.js implementation of IoInterface
@@ -62,19 +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 writeStream;
-    private reader;
-    name: string;
-    constructor(readStream: ReadableStream<Uint8Array>, writeStream: WritableStream<Uint8Array>);
-    read(): Promise<Buffer | null>;
-    write(data: string): Promise<void>;
-}
-
-export { DenoIo, DestroyableIoInterface, IoInterface, NodeIo, WebSocketClientIO, WebSocketServerIO };
+export { BunIo, DestroyableIoInterface, IoInterface, NodeIo, WebSocketClientIO, WebSocketServerIO };

package/dist/mod.js

@@ -1,11 +1,15 @@
 import {
+  TauriShellStdio,
   WorkerChildIO,
   WorkerParentIO
-} from "./chunk-XU7DWWSJ.js";
+} from "./chunk-KZFPA2BM.js";
 import {
   ChromeBackgroundIO,
   ChromeContentIO
 } from "./chunk-INKNKSKA.js";
+import {
+  DenoIo
+} from "./chunk-GRCUBSPR.js";
 import {
   HTTPClientIO,
   HTTPServerIO
@@ -19,6 +23,28 @@ import {
   serializeResponse
 } from "./chunk-ZSSFWNSX.js";
 
+// src/adapters/bun.ts
+import { Buffer } from "node:buffer";
+var BunIo = class {
+  name = "bun-io";
+  readStream;
+  reader;
+  constructor(readStream) {
+    this.readStream = readStream;
+    this.reader = this.readStream.getReader();
+  }
+  async read() {
+    const { value, done } = await this.reader.read();
+    if (done) {
+      return null;
+    }
+    return Buffer.from(value);
+  }
+  async write(data) {
+    return Bun.write(Bun.stdout, data).then(() => Promise.resolve());
+  }
+};
+
 // src/adapters/node.ts
 var NodeIo = class {
   name = "node-io";
@@ -165,32 +191,8 @@ var WebSocketServerIO = class {
     this.write(DESTROY_SIGNAL);
   }
 };
-
-// src/adapters/deno.ts
-import { Buffer } from "node:buffer";
-var DenoIo = class {
-  constructor(readStream, writeStream) {
-    this.readStream = readStream;
-    this.writeStream = writeStream;
-    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 {
+  BunIo,
   ChromeBackgroundIO,
   ChromeContentIO,
   DenoIo,
@@ -198,6 +200,7 @@ export {
   HTTPServerIO,
   NodeIo,
   RPCChannel,
+  TauriShellStdio,
   WebSocketClientIO,
   WebSocketServerIO,
   WorkerChildIO,

package/dist/{worker-DiYJxxHW.d.ts → tauri-CRNRbu3f.d.cts}

@@ -1,4 +1,5 @@
-import { D as DestroyableIoInterface } from './channel-D6ZClufP.js';
+import { D as DestroyableIoInterface, I as IoInterface } from './channel-D6ZClufP.cjs';
+import { EventEmitter, OutputEvents, Child } from '@tauri-apps/plugin-shell';
 
 declare class WorkerParentIO implements DestroyableIoInterface {
     name: string;
@@ -24,4 +25,14 @@ declare class WorkerChildIO implements DestroyableIoInterface {
     signalDestroy(): void;
 }
 
-export { WorkerParentIO as W, WorkerChildIO as a };
+declare class TauriShellStdio implements IoInterface {
+    private readStream;
+    private childProcess;
+    name: string;
+    constructor(readStream: EventEmitter<OutputEvents<string>>, // stdout of child process
+    childProcess: Child);
+    read(): Promise<string | Uint8Array | null>;
+    write(data: string): Promise<void>;
+}
+
+export { TauriShellStdio as T, WorkerParentIO as W, WorkerChildIO as a };

package/dist/{worker-72MNjMgj.d.cts → tauri-PdcZTVUI.d.ts}

@@ -1,4 +1,5 @@
-import { D as DestroyableIoInterface } from './channel-D6ZClufP.cjs';
+import { D as DestroyableIoInterface, I as IoInterface } from './channel-D6ZClufP.js';
+import { EventEmitter, OutputEvents, Child } from '@tauri-apps/plugin-shell';
 
 declare class WorkerParentIO implements DestroyableIoInterface {
     name: string;
@@ -24,4 +25,14 @@ declare class WorkerChildIO implements DestroyableIoInterface {
     signalDestroy(): void;
 }
 
-export { WorkerParentIO as W, WorkerChildIO as a };
+declare class TauriShellStdio implements IoInterface {
+    private readStream;
+    private childProcess;
+    name: string;
+    constructor(readStream: EventEmitter<OutputEvents<string>>, // stdout of child process
+    childProcess: Child);
+    read(): Promise<string | Uint8Array | null>;
+    write(data: string): Promise<void>;
+}
+
+export { TauriShellStdio as T, WorkerParentIO as W, WorkerChildIO as a };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "kkrpc",
-	"version": "0.2.0-beta.2",
+	"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",
@@ -67,6 +76,7 @@
 		"typescript": "^5.0.0"
 	},
 	"dependencies": {
+		"@tauri-apps/plugin-shell": "^2.2.0",
 		"superjson": "^2.2.2",
 		"ws": "^8.18.1"
 	},