@efffrida/frida-tools 0.0.26 → 0.0.28

package/src/internal/script.ts

@@ -1,27 +1,28 @@
 import type * as Scope from "effect/Scope";
 
-import * as FileSystem from "@effect/platform/FileSystem";
-import * as Path from "@effect/platform/Path";
 import * as Cause from "effect/Cause";
-import * as Chunk from "effect/Chunk";
 import * as Context from "effect/Context";
 import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
+import * as FileSystem from "effect/FileSystem";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
-import * as Mailbox from "effect/Mailbox";
 import * as Option from "effect/Option";
+import * as Path from "effect/Path";
 import * as Predicate from "effect/Predicate";
+import * as Queue from "effect/Queue";
 import * as Schema from "effect/Schema";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
-import * as Frida from "frida";
 
 import type * as FridaScript from "../FridaScript.ts";
 
+import * as Frida from "frida";
+
 import * as FridaSession from "../FridaSession.ts";
 import * as FridaSessionError from "../FridaSessionError.ts";
+import * as internalCompiler from "./compiler.ts";
 
 /** @internal */
 export const FridaScriptTypeId: FridaScript.FridaScriptTypeId = Symbol.for(
@@ -29,112 +30,11 @@ export const FridaScriptTypeId: FridaScript.FridaScriptTypeId = Symbol.for(
 ) as FridaScript.FridaScriptTypeId;
 
 /** @internal */
-export const Tag = Context.GenericTag<FridaScript.FridaScript>("@efffrida/frida-tools/FridaScript");
+export const Tag = Context.Service<FridaScript.FridaScript>("@efffrida/frida-tools/FridaScript");
 
 /** @internal */
 export const isFridaScript = (u: unknown): u is FridaScript.FridaScript => Predicate.hasProperty(u, FridaScriptTypeId);
 
-/** @internal */
-export const compile = Function.dual<
-    (
-        options?: Frida.CompilerOptions | undefined
-    ) => (path: string) => Effect.Effect<string, FridaSessionError.FridaSessionError, Scope.Scope>,
-    (
-        path: string,
-        options?: Frida.CompilerOptions | undefined
-    ) => Effect.Effect<string, FridaSessionError.FridaSessionError, Scope.Scope>
->(
-    (arguments_) => Predicate.isString(arguments_[0]),
-    (path: string, options?: Frida.CompilerOptions | undefined) =>
-        Effect.asyncEffect<string, FridaSessionError.FridaSessionError, never, never, never, Scope.Scope>(
-            Effect.fnUntraced(function* (resume) {
-                // https://github.com/frida/frida-compile/blob/e81ae27369466c69868fc6ee36c0f227bbfe340c/src/cli.ts#L173-L182
-                interface Diagnostic {
-                    category: string;
-                    code: number;
-                    text: string;
-                    file?: {
-                        path: string;
-                        line: number;
-                        character: number;
-                    };
-                }
-
-                const formatDiagnostic = (diagnostic: Diagnostic): FridaSessionError.FridaSessionError => {
-                    const location = diagnostic.file
-                        ? `${diagnostic.file.path}:${diagnostic.file.line}:${diagnostic.file.character}`
-                        : undefined;
-                    const message = `TS${diagnostic.code}: ${diagnostic.text}`;
-                    const cause = location ? `${location} - ${message}` : message;
-                    return new FridaSessionError.FridaSessionError({ cause, when: "compile" });
-                };
-
-                const compileErrors: Array<Diagnostic> = [];
-                const compiler = new Frida.Compiler();
-
-                const onOutput = (bundle: string) => resume(Effect.succeed(bundle));
-                yield* Effect.addFinalizer(() => Effect.sync(() => compiler.output.disconnect(onOutput)));
-                compiler.output.connect(onOutput);
-
-                const onDiagnostic = (diagnostic: Array<Diagnostic>) => {
-                    for (const diag of diagnostic) {
-                        if (diag.category === "error") {
-                            compileErrors.push(diag);
-                        }
-                    }
-                };
-                yield* Effect.addFinalizer(() => Effect.sync(() => compiler.diagnostics.disconnect(onDiagnostic)));
-                compiler.diagnostics.connect(onDiagnostic);
-
-                const onFinished = () => {
-                    if (compileErrors.length > 0) {
-                        resume(
-                            Effect.failCauseSync(() => {
-                                const [first, ...rest] = compileErrors;
-                                let cause = Cause.fail(formatDiagnostic(first));
-                                for (const diag of rest) {
-                                    cause = Cause.parallel(cause, Cause.fail(formatDiagnostic(diag)));
-                                }
-                                return cause;
-                            })
-                        );
-                    }
-                };
-                yield* Effect.addFinalizer(() => Effect.sync(() => compiler.finished.disconnect(onFinished)));
-                compiler.finished.connect(onFinished);
-
-                const cancellable = new Frida.Cancellable();
-                compiler
-                    .build(
-                        path,
-                        {
-                            externals: options?.externals,
-                            projectRoot: options?.projectRoot,
-                            platform: options?.platform ?? Frida.JsPlatform.Gum,
-                            typeCheck: options?.typeCheck ?? Frida.TypeCheckMode.Full,
-                            sourceMaps: options?.sourceMaps ?? Frida.SourceMaps.Included,
-                            compression: options?.compression ?? Frida.JsCompression.None,
-                            bundleFormat: options?.bundleFormat ?? Frida.BundleFormat.Esm,
-                            outputFormat: options?.outputFormat ?? Frida.OutputFormat.Unescaped,
-                        },
-                        cancellable
-                    )
-                    .catch((error) =>
-                        resume(
-                            Effect.fail(
-                                new FridaSessionError.FridaSessionError({
-                                    cause: error,
-                                    when: "compile",
-                                })
-                            )
-                        )
-                    );
-
-                return Effect.sync(() => cancellable.cancel());
-            })
-        )
-);
-
 /** @internal */
 export const load = Function.dual<
     (
@@ -156,202 +56,219 @@ export const load = Function.dual<
     >
 >(
     (arguments_) => Predicate.hasProperty(arguments_[0], "href"),
-    Effect.fnUntraced(
-        function* (entrypoint: URL, options?: FridaScript.LoadOptions | undefined) {
-            const path = yield* Path.Path;
-            const { session } = yield* FridaSession.FridaSession;
+    Effect.fnUntraced(function* (entrypoint: URL, options?: FridaScript.LoadOptions | undefined) {
+        const path = yield* Path.Path;
+        const { session } = yield* FridaSession.FridaSession;
 
-            const projectRoot = yield* path.fromFileUrl(entrypoint).pipe(
-                Effect.mapError(
-                    (cause) =>
-                        new FridaSessionError.FridaSessionError({
-                            when: "compile",
-                            cause,
-                        })
-                ),
-                Effect.map((p) => path.dirname(p))
-            );
-
-            const source = yield* path.fromFileUrl(entrypoint).pipe(
-                Effect.flatMap(
-                    compile({
-                        ...options,
-                        projectRoot: options?.projectRoot ?? projectRoot,
-                    })
-                ),
-                Effect.scoped,
-                Effect.timeoutFail({
-                    duration: "1 minute",
-                    onTimeout: () =>
-                        new FridaSessionError.FridaSessionError({
-                            when: "compile",
-                            cause: "TypeScript compilation timed out",
-                        }),
-                }),
-                Effect.catchTag(
-                    "BadArgument",
-                    (platformCause) =>
-                        new FridaSessionError.FridaSessionError({
-                            when: "compile",
-                            cause: platformCause,
-                        })
-                )
-            );
-
-            const script = yield* Effect.tryPromise({
-                try: (signal) => {
-                    const cancellable = new Frida.Cancellable();
-                    signal.onabort = () => cancellable.cancel();
-                    return session.createScript(
-                        source,
-                        {
-                            runtime: Frida.ScriptRuntime.V8,
-                            ...options,
-                        },
-                        cancellable
-                    );
-                },
-                catch: (cause) =>
+        const projectRoot = yield* path.fromFileUrl(entrypoint).pipe(
+            Effect.mapError(
+                (cause) =>
                     new FridaSessionError.FridaSessionError({
+                        when: "compile",
                         cause,
+                    })
+            ),
+            Effect.map((p) => path.dirname(p))
+        );
+
+        const source = yield* path.fromFileUrl(entrypoint).pipe(
+            Effect.flatMap(
+                internalCompiler.compile({
+                    ...options,
+                    projectRoot: options?.projectRoot ?? projectRoot,
+                })
+            ),
+            Effect.timeoutOrElse({
+                duration: "1 minute",
+                orElse: () =>
+                    new FridaSessionError.FridaSessionError({
+                        cause: "Compilation timed out",
                         when: "compile",
                     }),
-            });
+            }),
+            Effect.catchTag(
+                "BadArgument",
+                (platformCause) =>
+                    new FridaSessionError.FridaSessionError({
+                        cause: platformCause,
+                        when: "compile",
+                    })
+            )
+        );
 
-            const destroyed = yield* Deferred.make<void, never>();
-            const scriptError = yield* Deferred.make<unknown, never>();
-            const mailbox = yield* Mailbox.make<
-                { message: unknown; data: Option.Option<Buffer> },
-                FridaSessionError.FridaSessionError
-            >(options?.messageMailboxCapacity);
-            yield* Effect.addFinalizer(() => mailbox.shutdown); // TODO: is this needed?
-
-            const destroyedHandler: Frida.ScriptDestroyedHandler = () => {
-                Deferred.unsafeDone(destroyed, Effect.void);
-                mailbox.unsafeDone(
-                    Exit.fail(
-                        new FridaSessionError.FridaSessionError({
-                            cause: "Script destroyed",
-                            when: "message",
-                        })
-                    )
+        const script = yield* Effect.tryPromise({
+            try: (signal) => {
+                const cancellable = new Frida.Cancellable();
+                signal.onabort = () => cancellable.cancel();
+                return session.createScript(
+                    source,
+                    {
+                        runtime: Frida.ScriptRuntime.V8,
+                        ...options,
+                    },
+                    cancellable
                 );
-            };
-            yield* Effect.addFinalizer(() => Effect.sync(() => script.destroyed.disconnect(destroyedHandler)));
-            script.destroyed.connect(destroyedHandler);
-
-            const messageHandler: Frida.ScriptMessageHandler = (message: Frida.Message, data: Buffer | null): void => {
-                switch (message.type) {
-                    case Frida.MessageType.Error: {
-                        const cause = new Error();
-                        cause.name = "FridaScriptDefect";
-                        cause.stack = message.stack ?? "";
-                        cause.message = message.description.replace(/^\w{0,}: /, "") ?? "";
-                        Deferred.unsafeDone(scriptError, Exit.succeed(cause));
-                        mailbox.unsafeDone(
-                            Exit.fail(
-                                new FridaSessionError.FridaSessionError({
-                                    when: "message",
-                                    cause,
-                                })
-                            )
-                        );
-                        break;
-                    }
-
-                    case Frida.MessageType.Send: {
-                        mailbox.unsafeOffer({
-                            message: message.payload,
-                            data: Option.fromNullable(data),
-                        });
-                        break;
-                    }
-
-                    default: {
-                        return Function.absurd(message);
-                    }
-                }
-            };
-            yield* Effect.addFinalizer(() => Effect.sync(() => script.message.disconnect(messageHandler)));
-            script.message.connect(messageHandler);
-
-            const failIfScriptError = (when: FridaSessionError.FridaSessionError["when"]) =>
-                Effect.if(Deferred.isDone(scriptError), {
-                    onFalse: () => Effect.void,
-                    onTrue: () =>
-                        Effect.flatMap(
-                            Deferred.await(scriptError),
-                            (cause) => new FridaSessionError.FridaSessionError({ cause, when })
-                        ),
-                });
-
-            const failIfDestroyed = (when: FridaSessionError.FridaSessionError["when"]) =>
-                Effect.if(Deferred.isDone(destroyed), {
-                    onFalse: () => Effect.void,
-                    onTrue: () => new FridaSessionError.FridaSessionError({ cause: "Script is destroyed", when }),
-                });
-
-            const stream = yield* Stream.share(
-                Mailbox.toStream(mailbox),
-                options?.streamShareOptions ?? {
-                    replay: 100,
-                    capacity: "unbounded",
-                }
-            );
+            },
+            catch: (cause) =>
+                new FridaSessionError.FridaSessionError({
+                    when: "compile",
+                    cause,
+                }),
+        });
 
-            const sink = Sink.forEach<
-                { message: unknown; data: Option.Option<Buffer> },
-                void,
-                FridaSessionError.FridaSessionError,
-                never
-            >(
-                Effect.fnUntraced(function* ({ data, message }) {
-                    yield* failIfDestroyed("message");
-                    yield* failIfScriptError("message");
-                    script.post(message, Option.getOrNull(data));
-                })
+        yield* Effect.addFinalizer(() =>
+            Effect.promise((signal) => {
+                const cancellable = new Frida.Cancellable();
+                signal.onabort = () => cancellable.cancel();
+                return script.unload(cancellable);
+            })
+        );
+
+        const scriptError = yield* Deferred.make<unknown, never>();
+        const destroyed = yield* Deferred.make<void, never>();
+
+        const queue = yield* Queue.make<
+            { message: unknown; data: Option.Option<Buffer> },
+            FridaSessionError.FridaSessionError
+        >(options?.messageMailboxCapacity);
+        yield* Effect.addFinalizer(() => Queue.shutdown(queue));
+
+        const destroyedHandler: Frida.ScriptDestroyedHandler = () => {
+            Deferred.doneUnsafe(destroyed, Exit.void);
+            Queue.failCauseUnsafe(
+                queue,
+                Cause.fail(
+                    new FridaSessionError.FridaSessionError({
+                        cause: "Script destroyed",
+                        when: "message",
+                    })
+                )
             );
+        };
+        yield* Effect.addFinalizer(() => Effect.sync(() => script.destroyed.disconnect(destroyedHandler)));
+        script.destroyed.connect(destroyedHandler);
+
+        const messageHandler: Frida.ScriptMessageHandler = (message: Frida.Message, data: Buffer | null): void => {
+            switch (message.type) {
+                case Frida.MessageType.Error: {
+                    const cause = new Error();
+                    cause.name = "FridaScriptDefect";
+                    cause.stack = message.stack ?? "";
+                    cause.message = message.description.replace(/^\w{0,}: /, "") ?? "";
+                    Deferred.doneUnsafe(scriptError, Exit.succeed(cause));
+                    Queue.failCauseUnsafe(
+                        queue,
+                        Cause.fail(
+                            new FridaSessionError.FridaSessionError({
+                                when: "message",
+                                cause,
+                            })
+                        )
+                    );
+                    break;
+                }
 
-            const callExport = <A, I, R>(exportName: string, schema: Schema.Schema<A, I, R>) =>
-                Effect.fn(`call frida export ${exportName}`)(function* (...args: Array<any>) {
-                    yield* Effect.annotateCurrentSpan("args", args);
-                    yield* failIfDestroyed("rpcCall");
-                    yield* failIfScriptError("rpcCall");
-                    const result = yield* Effect.tryPromise({
-                        try: () => script.exports[exportName](...args) as Promise<unknown>,
-                        catch: (cause) => new FridaSessionError.FridaSessionError({ when: "rpcCall", cause }),
+                case Frida.MessageType.Send: {
+                    Queue.offerUnsafe(queue, {
+                        message: message.payload,
+                        data: Option.fromNullishOr(data),
                     });
-                    yield* Effect.annotateCurrentSpan("result", result);
-                    return yield* Schema.decodeUnknown(schema)(result);
-                });
+                    break;
+                }
 
-            yield* Effect.tryPromise({
-                try: (signal) => {
-                    const cancellable = new Frida.Cancellable();
-                    signal.onabort = () => cancellable.cancel();
-                    return script.load(cancellable);
-                },
-                catch: (cause) => new FridaSessionError.FridaSessionError({ cause, when: "load" }),
+                default: {
+                    return Function.absurd(message);
+                }
+            }
+        };
+        yield* Effect.addFinalizer(() => Effect.sync(() => script.message.disconnect(messageHandler)));
+        script.message.connect(messageHandler);
+
+        const failIfScriptError = Effect.fnUntraced(function* (when: FridaSessionError.FridaSessionError["when"]) {
+            const isDone = yield* Deferred.isDone(scriptError);
+            if (!isDone) return yield* Effect.void;
+            const cause = yield* Deferred.await(scriptError);
+            return yield* new FridaSessionError.FridaSessionError({
+                cause,
+                when,
+            });
+        });
+
+        const failIfDestroyed = Effect.fnUntraced(function* (when: FridaSessionError.FridaSessionError["when"]) {
+            const isDone = yield* Deferred.isDone(destroyed);
+            if (!isDone) return yield* Effect.void;
+            return yield* new FridaSessionError.FridaSessionError({
+                cause: "Script is destroyed",
+                when,
+            });
+        });
+
+        const stream = yield* Stream.share(
+            Stream.fromQueue(queue),
+            options?.streamShareOptions ?? {
+                strategy: "suspend",
+                capacity: 100,
+                replay: 100,
+            }
+        );
+
+        const sink = Sink.forEach<
+            { message: unknown; data: Option.Option<Buffer> },
+            void,
+            FridaSessionError.FridaSessionError,
+            never
+        >(
+            Effect.fnUntraced(function* ({ data, message }) {
+                yield* failIfDestroyed("message");
+                yield* failIfScriptError("message");
+                script.post(message, Option.getOrNull(data));
+            })
+        );
+
+        const callExport = <A = unknown, R = never>(exportName: string, schema?: Schema.Decoder<A, R> | undefined) =>
+            Effect.fn(`call frida export ${exportName}`)(function* (
+                ...args: Array<any>
+            ): Effect.fn.Return<A, FridaSessionError.FridaSessionError | Schema.SchemaError, R> {
+                yield* Effect.annotateCurrentSpan("args", args);
+                yield* failIfDestroyed("rpcCall");
+                yield* failIfScriptError("rpcCall");
+                const result = yield* Effect.tryPromise({
+                    try: () => script.exports[exportName](...args),
+                    catch: (cause) =>
+                        new FridaSessionError.FridaSessionError({
+                            when: "rpcCall",
+                            cause,
+                        }),
+                });
+                yield* Effect.annotateCurrentSpan("result", result);
+                const decoder = Schema.decodeEffect(schema ?? Schema.Unknown);
+                const decoded = yield* decoder(result);
+                return decoded as A;
             });
 
-            return {
-                sink,
-                stream,
-                script,
-                destroyed,
-                callExport,
-                scriptError,
-                [FridaScriptTypeId]: FridaScriptTypeId,
-            } as const;
-        },
-        Effect.acquireRelease(({ script }: FridaScript.FridaScript) =>
-            Effect.promise((signal) => {
+        yield* Effect.tryPromise({
+            try: (signal) => {
                 const cancellable = new Frida.Cancellable();
                 signal.onabort = () => cancellable.cancel();
-                return script.unload(cancellable);
-            })
-        )
-    )
+                return script.load(cancellable);
+            },
+            catch: (cause) =>
+                new FridaSessionError.FridaSessionError({
+                    when: "load",
+                    cause,
+                }),
+        });
+
+        return {
+            sink,
+            stream,
+            script,
+            destroyed,
+            callExport,
+            scriptError,
+            [FridaScriptTypeId]: FridaScriptTypeId,
+        } as const;
+    })
 );
 
 /** @internal */
@@ -368,7 +285,7 @@ export const layer = Function.dual<
 >(
     (arguments_) => Predicate.hasProperty(arguments_[0], "href"),
     (entrypoint: URL, options?: FridaScript.LoadOptions | undefined) =>
-        Layer.scoped(Tag, load(entrypoint, options)).pipe(Layer.provide(Path.layer))
+        Layer.effect(Tag, load(entrypoint, options)).pipe(Layer.provide(Path.layer))
 );
 
 /** @internal */
@@ -422,7 +339,7 @@ export const watch = Function.dual<
 
             return fileSystem.watch(pathString).pipe(
                 Stream.filter((event) => event._tag === "Update"),
-                Stream.prepend(Chunk.of(FileSystem.WatchEventUpdate({ path: pathString }))),
+                Stream.prepend([{ _tag: "Update" as const, path: pathString }]),
                 Stream.debounce("2 second"),
                 Stream.mapError(
                     (cause) =>
@@ -444,7 +361,7 @@ export const watch = Function.dual<
             );
         },
         Stream.unwrap,
-        Stream.provideSomeLayer(Path.layer)
+        Stream.provide(Path.layer)
     )
 );
 
@@ -462,12 +379,12 @@ export const logWatchErrors = <A, E1, E2, R>(
         const cause = exit.cause;
 
         // Interruption only
-        if (Cause.isInterruptedOnly(cause)) {
+        if (Cause.hasInterruptsOnly(cause)) {
             return Effect.logDebug("Script interrupted with no errors");
         }
 
         // Defect
-        if (Cause.isDie(cause)) {
+        if (Cause.hasDies(cause)) {
             return Effect.logError(cause);
         }