@efffrida/rpc 0.0.27 → 0.0.28

package/src/node/FridaRpcServer.ts

@@ -7,119 +7,121 @@
 
 import type * as Scope from "effect/Scope";
 
-import * as RpcMessage from "@effect/rpc/RpcMessage";
-import * as RpcSerialization from "@effect/rpc/RpcSerialization";
-import * as RpcServer from "@effect/rpc/RpcServer";
-import * as FridaScript from "@efffrida/frida-tools/FridaScript";
-import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
-import * as Mailbox from "effect/Mailbox";
+import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
-import * as Schema from "effect/Schema";
+import * as Queue from "effect/Queue";
 import * as Stream from "effect/Stream";
 import * as String from "effect/String";
-import * as Tuple from "effect/Tuple";
+import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import * as RpcServer from "effect/unstable/rpc/RpcServer";
+
+import * as FridaScript from "@efffrida/frida-tools/FridaScript";
 
-import * as constants from "../shared/constants.ts";
-import * as predicates from "../shared/predicates.ts";
+import * as constants from "../shared/Constants.ts";
 
 /**
  * @since 1.0.0
  * @category Protocol
  */
 export const makeProtocolFrida = (): Effect.Effect<
-    unknown,
+    RpcServer.Protocol["Service"],
     never,
     FridaScript.FridaScript | RpcSerialization.RpcSerialization | Scope.Scope
 > =>
     Effect.gen(function* () {
-        const encoder = new TextEncoder();
-        const script = yield* FridaScript.FridaScript;
         const serialization = yield* RpcSerialization.RpcSerialization;
+        const script = yield* FridaScript.FridaScript;
+
+        const disconnects = yield* Queue.unbounded<number>();
+        const parser = serialization.makeUnsafe();
+        const encoder = new TextEncoder();
 
         let clientId = 0;
         const clientIds = new Set<number>();
-        const parser = serialization.unsafeMake();
-        const disconnects = yield* Mailbox.make<number>();
-
-        let writeRequest!: (clientId: number, message: RpcMessage.FromClientEncoded) => Effect.Effect<void>;
+        const clientIdsByExports = new Map<string, number>();
+        const clients = new Map<
+            number,
+            {
+                readonly write: (bytes: RpcMessage.FromServerEncoded) => void;
+            }
+        >();
 
-        // Listen for new clients
-        yield* script.stream.pipe(
-            Stream.filterMap(({ message }) => {
-                if (predicates.newClientPredicate(message)) {
-                    const stripPrefix = String.replace(constants.nodeRpcClientConnectionRequestMessagePrefix, "");
-                    return Option.some(stripPrefix(message));
-                } else {
-                    return Option.none();
-                }
-            }),
-            Stream.runForEach((exportName) => {
-                const id = clientId++;
-                clientIds.add(id);
-                return script.callExport(exportName, Schema.Void)(clientId++);
-            }),
-            Stream.tapError(Console.error),
-            Stream.runDrain,
-            Effect.forkScoped
+        const stripPrefix = String.replace(constants.nodeRpcClientConnectionRequestMessagePrefix, "");
+        const newClientPredicate: Predicate.Refinement<unknown, string> = Predicate.compose(
+            Predicate.isString,
+            String.startsWith(constants.nodeRpcClientConnectionRequestMessagePrefix)
+        );
+        const clientMessagePredicate: Predicate.Refinement<unknown, string> = Predicate.compose(
+            Predicate.isString,
+            (message) => clientIdsByExports.has(message)
         );
 
-        // Listen for messages from connected clients
-        yield* script.stream.pipe(
-            Stream.filterMap(({ data: maybeData, message }) => {
-                if (predicates.isTaggedForAnyClient(message)) {
-                    return Option.map(maybeData, (data) => Tuple.make(message.clientId, data));
-                } else {
-                    return Option.none();
-                }
-            }),
-            Stream.runForEach(([clientId, data]) => {
+        let writeRequest!: (clientId: number, message: RpcMessage.FromClientEncoded) => Effect.Effect<void>;
+        const makeRawWriter =
+            (exportName: string) =>
+            (data: string | Uint8Array): Effect.Effect<void> => {
+                const transformed = typeof data === "string" ? encoder.encode(data) : data;
+                return script.callExport(exportName)(transformed).pipe(Effect.orDie);
+            };
+
+        const onClientConnect = (message: string): Effect.Effect<void> => {
+            const writeRaw = makeRawWriter(stripPrefix(message));
+            const write = (response: RpcMessage.FromServerEncoded): Effect.Effect<void> => {
                 try {
-                    const decoded = parser.decode(data) as ReadonlyArray<RpcMessage.FromClientEncoded>;
-                    if (decoded.length === 0) return Effect.void;
-                    let i = 0;
-                    return Effect.whileLoop({
-                        while: () => i < decoded.length,
-                        body() {
-                            const message = decoded[i++];
-                            return writeRequest(clientId, message);
-                        },
-                        step: Function.constVoid,
-                    });
+                    const encoded = parser.encode(response);
+                    if (encoded === undefined) return Effect.void;
+                    return writeRaw(encoded);
                 } catch (cause) {
-                    return Effect.sync(() => {
-                        const encoded = parser.encode(RpcMessage.ResponseDefectEncoded(cause))!;
-                        const transformed = typeof encoded === "string" ? encoder.encode(encoded) : encoded;
-                        script.script.post({ clientId }, Buffer.from(transformed));
-                    });
+                    const encoded = parser.encode(RpcMessage.ResponseDefectEncoded(cause))!;
+                    return writeRaw(encoded);
                 }
-            }),
-            Stream.tapError(Console.error),
-            Stream.runDrain,
-            Effect.forkScoped
-        );
+            };
+
+            const id = ++clientId;
+            clientIdsByExports.set(stripPrefix(message), id);
+            clients.set(id, { write });
+            clientIds.add(id);
+            return Effect.void;
+        };
+
+        const onMessage = (exportName: string, data: Uint8Array): Effect.Effect<void> => {
+            try {
+                const id = clientIdsByExports.get(exportName)!;
+                const decoded = parser.decode(data) as ReadonlyArray<RpcMessage.FromClientEncoded>;
+                if (decoded.length === 0) return Effect.void;
+                let i = 0;
+                return Effect.whileLoop({
+                    while: () => i < decoded.length,
+                    step: Function.constVoid,
+                    body() {
+                        const message = decoded[i++];
+                        return writeRequest(id, message);
+                    },
+                });
+            } catch (cause) {
+                const writeRaw = makeRawWriter(exportName);
+                return writeRaw(parser.encode(RpcMessage.ResponseDefectEncoded(cause))!);
+            }
+        };
+
+        yield* Stream.runForEach(script.stream, ({ message, data }) => {
+            if (newClientPredicate(message)) return onClientConnect(message);
+            if (clientMessagePredicate(message) && Option.isSome(data)) return onMessage(message, data.value);
+            return Effect.void;
+        }).pipe(Effect.forkScoped);
 
         return yield* RpcServer.Protocol.make((_writeRequest) => {
             writeRequest = _writeRequest;
             return Effect.succeed({
                 disconnects,
                 send: (clientId, response) => {
-                    const writeRaw = (data: string | Uint8Array) => {
-                        const transformed = typeof data === "string" ? encoder.encode(data) : data;
-                        script.script.post({ clientId }, Buffer.from(transformed));
-                        return Effect.void;
-                    };
-
-                    try {
-                        const encoded = parser.encode(response);
-                        if (Predicate.isNotUndefined(encoded)) return writeRaw(encoded);
-                        else return Effect.void;
-                    } catch (cause) {
-                        const encoded = parser.encode(RpcMessage.ResponseDefectEncoded(cause))!;
-                        return writeRaw(encoded);
-                    }
+                    const client = clients.get(clientId);
+                    if (!client) return Effect.void;
+                    return Effect.sync(() => client.write(response));
                 },
                 end(_clientId) {
                     return Effect.void;
@@ -132,3 +134,13 @@ export const makeProtocolFrida = (): Effect.Effect<
             });
         });
     });
+
+/**
+ * @since 1.0.0
+ * @category Layer
+ */
+export const layerProtocolFrida: Layer.Layer<
+    RpcServer.Protocol,
+    never,
+    FridaScript.FridaScript | RpcSerialization.RpcSerialization
+> = Layer.effect(RpcServer.Protocol, makeProtocolFrida());

package/src/shared/Constants.ts

@@ -0,0 +1,13 @@
+/**
+ * Constants for working with RPC servers and clients.
+ *
+ * @since 1.0.0
+ */
+
+export const defaultServerMainExportName = "rpc";
+export const generateServerExportNameForClient = (clientId: number): string =>
+    `@efffrida/rpc/FridaServerRpcListenerForClient/${clientId}`;
+
+export const nodeRpcClientConnectionRequestMessagePrefix = "@efffrida/rpc/NodeRpcClientConnectionRequest/";
+export const nodeRpcClientMakeConnectionRequestForServer = (exportName: string) =>
+    `${nodeRpcClientConnectionRequestMessagePrefix}${exportName}`;

package/src/shared/index.ts

@@ -0,0 +1,10 @@
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * Constants for working with RPC servers and clients.
+ *
+ * @since 1.0.0
+ */
+export * as Constants from "./Constants.ts"

package/dist/shared/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/shared/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,QAAQ,CAAC;AACjD,eAAO,MAAM,iCAAiC,GAAI,UAAU,MAAM,KAAG,MACN,CAAC;AAGhE,eAAO,MAAM,yCAAyC,QAAO,MACY,CAAC;AAE1E,eAAO,MAAM,2CAA2C,8BAA8B,CAAC;AACvF,eAAO,MAAM,2CAA2C,GAAI,YAAY,MAAM,WACZ,CAAC"}

package/dist/shared/constants.js

@@ -1,7 +0,0 @@
-export const defaultServerMainExportName = "rpc";
-export const generateServerExportNameForClient = clientId => `@efffrida/rpc/FridaServerRpcListenerForClient/${clientId}`;
-let exportIdForClientCallback = 0;
-export const generateClientCallbackExportNameForServer = () => `@efffrida/rpc/FridaClientRpcCallback/${exportIdForClientCallback++}`;
-export const nodeRpcClientConnectionRequestMessagePrefix = "client id request message";
-export const nodeRpcClientMakeConnectionRequestForServer = exportName => `${nodeRpcClientConnectionRequestMessagePrefix}:${exportName}`;
-//# sourceMappingURL=constants.js.map

package/dist/shared/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","names":["defaultServerMainExportName","generateServerExportNameForClient","clientId","exportIdForClientCallback","generateClientCallbackExportNameForServer","nodeRpcClientConnectionRequestMessagePrefix","nodeRpcClientMakeConnectionRequestForServer","exportName"],"sources":["../../src/shared/constants.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,MAAMA,2BAA2B,GAAG,KAAK;AAChD,OAAO,MAAMC,iCAAiC,GAAIC,QAAgB,IAC9D,iDAAiDA,QAAQ,EAAE;AAE/D,IAAIC,yBAAyB,GAAW,CAAC;AACzC,OAAO,MAAMC,yCAAyC,GAAGA,CAAA,KACrD,wCAAwCD,yBAAyB,EAAE,EAAE;AAEzE,OAAO,MAAME,2CAA2C,GAAG,2BAA2B;AACtF,OAAO,MAAMC,2CAA2C,GAAIC,UAAkB,IAC1E,GAAGF,2CAA2C,IAAIE,UAAU,EAAE","ignoreList":[]}

package/dist/shared/predicates.d.ts

@@ -1,10 +0,0 @@
-import * as Predicate from "effect/Predicate";
-export declare const isClientId: (clientId: number) => Predicate.Refinement<unknown, number>;
-export declare const isTaggedForClient: (clientId: number) => Predicate.Refinement<unknown, {
-    readonly clientId: number;
-}>;
-export declare const isTaggedForAnyClient: Predicate.Refinement<unknown, {
-    readonly clientId: number;
-}>;
-export declare const newClientPredicate: Predicate.Refinement<unknown, string>;
-//# sourceMappingURL=predicates.d.ts.map

package/dist/shared/predicates.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"predicates.d.ts","sourceRoot":"","sources":["../../src/shared/predicates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,kBAAkB,CAAC;AAK9C,eAAO,MAAM,UAAU,GAAI,UAAU,MAAM,0CAAmE,CAAC;AAE/G,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM;;EAC8C,CAAC;AAEjG,eAAO,MAAM,oBAAoB;;EAGhC,CAAC;AAEF,eAAO,MAAM,kBAAkB,uCAG9B,CAAC"}

package/dist/shared/predicates.js

@@ -1,12 +0,0 @@
-import * as Predicate from "effect/Predicate";
-import * as String from "effect/String";
-import * as constants from "./constants.js";
-export const isClientId = clientId => Predicate.compose(Predicate.isNumber, id => id === clientId);
-export const isTaggedForClient = clientId => Predicate.compose(Predicate.isUnknown, Predicate.struct({
-  clientId: isClientId(clientId)
-}));
-export const isTaggedForAnyClient = /*#__PURE__*/Predicate.compose(Predicate.isUnknown, /*#__PURE__*/Predicate.struct({
-  clientId: Predicate.isNumber
-}));
-export const newClientPredicate = /*#__PURE__*/Predicate.compose(Predicate.isString, /*#__PURE__*/String.startsWith(constants.nodeRpcClientConnectionRequestMessagePrefix));
-//# sourceMappingURL=predicates.js.map

package/dist/shared/predicates.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"predicates.js","names":["Predicate","String","constants","isClientId","clientId","compose","isNumber","id","isTaggedForClient","isUnknown","struct","isTaggedForAnyClient","newClientPredicate","isString","startsWith","nodeRpcClientConnectionRequestMessagePrefix"],"sources":["../../src/shared/predicates.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,KAAKA,SAAS,MAAM,kBAAkB;AAC7C,OAAO,KAAKC,MAAM,MAAM,eAAe;AAEvC,OAAO,KAAKC,SAAS,MAAM,gBAAgB;AAE3C,OAAO,MAAMC,UAAU,GAAIC,QAAgB,IAAKJ,SAAS,CAACK,OAAO,CAACL,SAAS,CAACM,QAAQ,EAAGC,EAAE,IAAKA,EAAE,KAAKH,QAAQ,CAAC;AAE9G,OAAO,MAAMI,iBAAiB,GAAIJ,QAAgB,IAC9CJ,SAAS,CAACK,OAAO,CAACL,SAAS,CAACS,SAAS,EAAET,SAAS,CAACU,MAAM,CAAC;EAAEN,QAAQ,EAAED,UAAU,CAACC,QAAQ;AAAC,CAAE,CAAC,CAAC;AAEhG,OAAO,MAAMO,oBAAoB,gBAAGX,SAAS,CAACK,OAAO,CACjDL,SAAS,CAACS,SAAS,eACnBT,SAAS,CAACU,MAAM,CAAC;EAAEN,QAAQ,EAAEJ,SAAS,CAACM;AAAQ,CAAE,CAAC,CACrD;AAED,OAAO,MAAMM,kBAAkB,gBAAGZ,SAAS,CAACK,OAAO,CAC/CL,SAAS,CAACa,QAAQ,eAClBZ,MAAM,CAACa,UAAU,CAACZ,SAAS,CAACa,2CAA2C,CAAC,CAC3E","ignoreList":[]}

package/src/shared/constants.ts

@@ -1,11 +0,0 @@
-export const defaultServerMainExportName = "rpc";
-export const generateServerExportNameForClient = (clientId: number): string =>
-    `@efffrida/rpc/FridaServerRpcListenerForClient/${clientId}`;
-
-let exportIdForClientCallback: number = 0;
-export const generateClientCallbackExportNameForServer = (): string =>
-    `@efffrida/rpc/FridaClientRpcCallback/${exportIdForClientCallback++}`;
-
-export const nodeRpcClientConnectionRequestMessagePrefix = "client id request message";
-export const nodeRpcClientMakeConnectionRequestForServer = (exportName: string) =>
-    `${nodeRpcClientConnectionRequestMessagePrefix}:${exportName}`;

package/src/shared/predicates.ts

@@ -1,19 +0,0 @@
-import * as Predicate from "effect/Predicate";
-import * as String from "effect/String";
-
-import * as constants from "./constants.ts";
-
-export const isClientId = (clientId: number) => Predicate.compose(Predicate.isNumber, (id) => id === clientId);
-
-export const isTaggedForClient = (clientId: number) =>
-    Predicate.compose(Predicate.isUnknown, Predicate.struct({ clientId: isClientId(clientId) }));
-
-export const isTaggedForAnyClient = Predicate.compose(
-    Predicate.isUnknown,
-    Predicate.struct({ clientId: Predicate.isNumber })
-);
-
-export const newClientPredicate = Predicate.compose(
-    Predicate.isString,
-    String.startsWith(constants.nodeRpcClientConnectionRequestMessagePrefix)
-);