@efffrida/rpc 0.0.1

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@efffrida/rpc",
+  "version": "0.0.1",
+  "description": "effect rpc-frida",
+  "license": "GPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/leoconforti/efffrida.git",
+    "directory": "packages/rpc"
+  },
+  "sideEffects": [],
+  "author": "Leo Conforti <leo@leoconforti.us> (https://leoconforti.us)",
+  "homepage": "https://github.com/leoconforti/efffrida",
+  "dependencies": {
+    "@efffrida/frida-tools": "^0.0.1"
+  },
+  "peerDependencies": {
+    "@effect/platform": "0.80.8",
+    "@effect/rpc": "0.55.10",
+    "effect": "3.14.7"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/dts/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/dts/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/cjs/index.js"
+    },
+    "./FridaRpcClient": {
+      "types": "./dist/dts/FridaRpcClient.d.ts",
+      "import": "./dist/esm/FridaRpcClient.js",
+      "default": "./dist/cjs/FridaRpcClient.js"
+    },
+    "./FridaRpcServer": {
+      "types": "./dist/dts/FridaRpcServer.d.ts",
+      "import": "./dist/esm/FridaRpcServer.js",
+      "default": "./dist/cjs/FridaRpcServer.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "FridaRpcClient": [
+        "./dist/dts/FridaRpcClient.d.ts"
+      ],
+      "FridaRpcServer": [
+        "./dist/dts/FridaRpcServer.d.ts"
+      ]
+    }
+  }
+}

package/src/FridaRpcClient.ts

@@ -0,0 +1,113 @@
+/**
+ * Implements a Frida RPC client protocol for effect using the frida script
+ * exports. The reason we don't use the send/recv script channels is because
+ * those are shared channels by everybody.
+ *
+ * @since 1.0.0
+ */
+
+import type * as RpcMessage from "@effect/rpc/RpcMessage";
+import type * as FridaSessionError from "@efffrida/frida-tools/FridaSessionError";
+import type * as Types from "effect/Types";
+
+import * as RpcClient from "@effect/rpc/RpcClient";
+import * as RpcSerialization from "@effect/rpc/RpcSerialization";
+import * as FridaScript from "@efffrida/frida-tools/FridaScript";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export const makeProtocolFrida = (
+    script: FridaScript.FridaScript,
+    options?:
+        | {
+              readonly exportName?: string | undefined;
+              readonly rpcIsAvailableWhen?: ((message: string) => boolean) | undefined;
+          }
+        | undefined
+): Effect.Effect<RpcClient.Protocol["Type"], FridaSessionError.FridaSessionError, RpcSerialization.RpcSerialization> =>
+    RpcClient.Protocol.make(
+        Effect.fnUntraced(function* (writeResponse) {
+            const serialization = yield* RpcSerialization.RpcSerialization;
+            const exportName = options?.exportName ?? "rpc";
+            const rpcIsAvailableWhen = options?.rpcIsAvailableWhen;
+
+            const send = (request: RpcMessage.FromClientEncoded): Effect.Effect<void> => {
+                if (request._tag !== "Request") {
+                    return Effect.void;
+                }
+
+                const parser = serialization.unsafeMake();
+                if (!serialization.supportsBigInt) {
+                    const mutable = request as Types.Mutable<typeof request>;
+                    mutable.id = request.id.toString();
+                }
+
+                const schema = Schema.Union(Schema.String, Schema.Uint8Array);
+                const encode = Function.compose(parser.encode, Schema.encode(schema));
+                const decode = Function.compose(Schema.decodeUnknownSync(schema), parser.decode);
+
+                return encode(request)
+                    .pipe(Effect.flatMap(script.callExport(exportName)))
+                    .pipe(Effect.orDie)
+                    .pipe(
+                        Effect.flatMap((incoming) => {
+                            try {
+                                const responses = decode(incoming) as Array<RpcMessage.FromServerEncoded>;
+                                if (responses.length === 0) return Effect.void;
+                                let i = 0;
+                                return Effect.whileLoop({
+                                    while: () => i < responses.length,
+                                    body: () => writeResponse(responses[i++]),
+                                    step: Function.constVoid,
+                                });
+                            } catch (defect) {
+                                return writeResponse({ _tag: "Defect", defect });
+                            }
+                        })
+                    );
+            };
+
+            if (Predicate.isNotUndefined(rpcIsAvailableWhen)) {
+                yield* script.stream
+                    .pipe(Stream.map(({ message }) => message))
+                    .pipe(Stream.filter(Predicate.isString))
+                    .pipe(Stream.takeUntil(rpcIsAvailableWhen))
+                    .pipe(Stream.runDrain);
+            }
+
+            return {
+                send,
+                supportsAck: false,
+                supportsTransferables: false,
+            };
+        })
+    );
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerProtocolFrida = (
+    options?:
+        | {
+              readonly exportName?: string | undefined;
+              readonly rpcIsAvailableWhen?: ((message: string) => boolean) | undefined;
+          }
+        | undefined
+): Layer.Layer<
+    RpcClient.Protocol,
+    FridaSessionError.FridaSessionError,
+    RpcSerialization.RpcSerialization | FridaScript.FridaScript
+> =>
+    Layer.effect(
+        RpcClient.Protocol,
+        Effect.flatMap(FridaScript.FridaScript, (script) => makeProtocolFrida(script, options))
+    );

package/src/FridaRpcServer.ts

@@ -0,0 +1,165 @@
+/**
+ * Implements a Frida RPC server protocol for effect using the frida script
+ * exports. The reason we don't use the send/recv script channels is because
+ * those are shared channels by everybody.
+ *
+ * @since 1.0.0
+ */
+
+import type * as Types from "effect/Types";
+
+import * as RpcMessage from "@effect/rpc/RpcMessage";
+import * as RpcSerialization from "@effect/rpc/RpcSerialization";
+import * as RpcServer from "@effect/rpc/RpcServer";
+import * as Array from "effect/Array";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Mailbox from "effect/Mailbox";
+import * as Predicate from "effect/Predicate";
+import * as Runtime from "effect/Runtime";
+import * as Schema from "effect/Schema";
+
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export const makeProtocolFrida: Effect.Effect<
+    {
+        protocol: RpcServer.Protocol["Type"];
+        rpcExport: (request: string | Uint8Array) => Promise<string | ReadonlyArray<number>>;
+    },
+    never,
+    RpcSerialization.RpcSerialization
+> = Effect.gen(function* () {
+    const runtime = yield* Effect.runtime<never>();
+    const disconnects = yield* Mailbox.make<number>();
+    const serialization = yield* RpcSerialization.RpcSerialization;
+
+    let clientId = 0;
+    const clients = new Map<
+        number,
+        {
+            readonly end: Effect.Effect<void, never, never>;
+            readonly write: (bytes: RpcMessage.FromServerEncoded) => Effect.Effect<void>;
+        }
+    >();
+    let writeRequest!: (clientId: number, message: RpcMessage.FromClientEncoded) => Effect.Effect<void>;
+
+    const rpcExport = async function (request: string | Uint8Array): Promise<string | ReadonlyArray<number>> {
+        const id = clientId++;
+        const parser = serialization.unsafeMake();
+
+        const chunks = Array.empty<string | ReadonlyArray<number>>();
+        const deferred = await Runtime.runPromise(runtime, Deferred.make<string | ReadonlyArray<number>, never>());
+
+        const schema = Schema.Union(Schema.String, Schema.Uint8Array);
+        const encode = Function.compose(parser.encode, Schema.encodeSync(schema));
+        const decode = Function.compose(Schema.decodeUnknownSync(schema), parser.decode);
+
+        clients.set(id, {
+            end: Effect.void,
+            write: (response: RpcMessage.FromServerEncoded) => {
+                try {
+                    if (!serialization.supportsBigInt && "requestId" in response) {
+                        const mutable = response as Types.Mutable<typeof response>;
+                        mutable.requestId = mutable.requestId.toString();
+                    }
+
+                    chunks.push(encode(response));
+                    if (Predicate.isTagged(response, "Chunk")) return Effect.void;
+
+                    const final = Predicate.isString(chunks[0])
+                        ? chunks.join("")
+                        : Array.flatten(chunks as Array<ReadonlyArray<number>>);
+                    return Deferred.succeed(deferred, final);
+                } catch (cause) {
+                    const message = RpcMessage.ResponseDefectEncoded(cause);
+                    const encoded = encode(message);
+                    return Deferred.succeed(deferred, encoded);
+                }
+            },
+        });
+
+        try {
+            const decoded = decode(request) as ReadonlyArray<RpcMessage.FromClientEncoded>;
+            if (decoded.length === 0) return "";
+            let i = 0;
+            await Runtime.runPromise(
+                runtime,
+                Effect.whileLoop({
+                    while: () => i < decoded.length,
+                    body: () => writeRequest(id, decoded[i++]),
+                    step: Function.constVoid,
+                })
+            );
+        } catch (cause) {
+            const message = RpcMessage.ResponseDefectEncoded(cause);
+            const encoded = encode(message);
+            return Promise.resolve(encoded);
+        }
+
+        return Runtime.runPromise(runtime, deferred);
+    };
+
+    const protocol = yield* RpcServer.Protocol.make((writeRequest_) => {
+        writeRequest = writeRequest_;
+        return Effect.succeed({
+            disconnects,
+            send: (clientId, response) => {
+                const client = clients.get(clientId);
+                if (!client) return Effect.void;
+                return client.write(response);
+            },
+            end(clientId) {
+                const client = clients.get(clientId);
+                if (!client) return Effect.void;
+                clients.delete(clientId);
+                return client.end;
+            },
+            initialMessage: Effect.succeedNone,
+            supportsAck: false,
+            supportsTransferables: false,
+            supportsSpanPropagation: false,
+        });
+    });
+
+    return { protocol, rpcExport };
+});
+
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export const makeProtocolFridaWithExport = (
+    options?:
+        | {
+              readonly exportName?: string | undefined;
+              readonly messageOnRpcAvailable?: string | undefined;
+          }
+        | undefined
+) =>
+    Effect.gen(function* () {
+        const { protocol, rpcExport } = yield* makeProtocolFrida;
+        rpc.exports[options?.exportName ?? "rpc"] = rpcExport;
+        const messageOnRpcAvailable = options?.messageOnRpcAvailable;
+        if (Predicate.isNotUndefined(messageOnRpcAvailable)) {
+            send(messageOnRpcAvailable);
+        }
+        return protocol;
+    });
+
+/**
+ * @since 1.0.0
+ * @category Layer
+ */
+export const layerProtocolFrida = (
+    options?:
+        | {
+              readonly exportName?: string | undefined;
+              readonly messageOnRpcAvailable?: string | undefined;
+          }
+        | undefined
+): Layer.Layer<RpcServer.Protocol, never, RpcSerialization.RpcSerialization> =>
+    Layer.effect(RpcServer.Protocol, makeProtocolFridaWithExport(options));

package/src/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Implements a Frida RPC client protocol for effect using the frida script
+ * exports. The reason we don't use the send/recv script channels is because
+ * those are shared channels by everybody.
+ *
+ * @since 1.0.0
+ */
+export * as FridaRpcClient from "./FridaRpcClient.js"
+
+/**
+ * Implements a Frida RPC server protocol for effect using the frida script
+ * exports. The reason we don't use the send/recv script channels is because
+ * those are shared channels by everybody.
+ *
+ * @since 1.0.0
+ */
+export * as FridaRpcServer from "./FridaRpcServer.js"