@efffrida/frida-tools 0.0.14 → 0.0.16

package/src/internal/script.ts

@@ -1,21 +1,24 @@
 import type * as Scope from "effect/Scope";
-import type * as FridaScript from "../FridaScript.js";
+import type * as FridaScript from "../FridaScript.ts";
 
+import * as Path from "@effect/platform/Path";
+import * as Cause from "effect/Cause";
 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 Function from "effect/Function";
 import * as Layer from "effect/Layer";
+import * as Mailbox from "effect/Mailbox";
 import * as Option from "effect/Option";
 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 Take from "effect/Take";
 import * as Frida from "frida";
-import * as FridaDevice from "../FridaDevice.js";
-import * as FridaSession from "../FridaSession.js";
-import * as FridaSessionError from "../FridaSessionError.js";
+
+import * as FridaSession from "../FridaSession.ts";
+import * as FridaSessionError from "../FridaSessionError.ts";
 
 /** @internal */
 export const FridaScriptTypeId: FridaScript.FridaScriptTypeId = Symbol.for(
@@ -28,182 +31,347 @@ export const Tag = Context.GenericTag<FridaScript.FridaScript>("@efffrida/frida-
 /** @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<
     (
-        options?: (Frida.ScriptOptions & { readonly resume?: boolean | undefined }) | undefined
+        options?: FridaScript.LoadOptions | undefined
     ) => (
-        source: string | Buffer
+        entrypoint: URL
     ) => Effect.Effect<
         FridaScript.FridaScript,
         FridaSessionError.FridaSessionError,
-        FridaSession.FridaSession | FridaDevice.FridaDevice | Scope.Scope
+        Path.Path | FridaSession.FridaSession | Scope.Scope
     >,
     (
-        source: string | Buffer,
-        options?: (Frida.ScriptOptions & { readonly resume?: boolean | undefined }) | undefined
+        entrypoint: URL,
+        options?: FridaScript.LoadOptions | undefined
     ) => Effect.Effect<
         FridaScript.FridaScript,
         FridaSessionError.FridaSessionError,
-        FridaSession.FridaSession | FridaDevice.FridaDevice | Scope.Scope
+        Path.Path | FridaSession.FridaSession | Scope.Scope
     >
 >(
-    (arguments_) => Predicate.isString(arguments_[0]) || Buffer.isBuffer(arguments_[0]),
+    (arguments_) => Predicate.hasProperty(arguments_[0], "href"),
     Effect.fnUntraced(
-        function* (
-            source: string | Buffer,
-            options?: (Frida.ScriptOptions & { readonly resume?: boolean | undefined }) | undefined
-        ) {
-            const { device } = yield* FridaDevice.FridaDevice;
+        function* (entrypoint: URL, options?: FridaScript.LoadOptions | undefined) {
+            const path = yield* Path.Path;
             const { session } = yield* FridaSession.FridaSession;
 
-            const script = Predicate.isString(source)
-                ? yield* Effect.tryPromise({
-                      try: () => session.createScript(source, { runtime: Frida.ScriptRuntime.V8, ...options }),
-                      catch: (cause) => new FridaSessionError.FridaSessionError({ cause, when: "compile" }),
-                  })
-                : yield* Effect.tryPromise({
-                      try: () => session.createScriptFromBytes(source, { runtime: Frida.ScriptRuntime.V8, ...options }),
-                      catch: (cause) => new FridaSessionError.FridaSessionError({ cause, when: "compile" }),
-                  });
-
-            const messageQueue =
-                yield* Queue.unbounded<
-                    Take.Take<{ message: any; data: Option.Option<Buffer> }, FridaSessionError.FridaSessionError>
-                >();
-
-            let scriptDefectCause: unknown = undefined;
+            const projectRoot = yield* path
+                .fromFileUrl(entrypoint)
+                .pipe(
+                    Effect.mapError(
+                        (cause) =>
+                            new FridaSessionError.FridaSessionError({
+                                when: "compile",
+                                cause,
+                            })
+                    )
+                )
+                .pipe(Effect.map((p) => path.dirname(p)));
+
+            const source = yield* path
+                .fromFileUrl(entrypoint)
+                .pipe(
+                    Effect.flatMap(
+                        compile({
+                            ...options,
+                            projectRoot: options?.projectRoot ?? projectRoot,
+                        })
+                    )
+                )
+                .pipe(Effect.scoped)
+                .pipe(
+                    Effect.timeoutFail({
+                        duration: "1 minute",
+                        onTimeout: () =>
+                            new FridaSessionError.FridaSessionError({
+                                when: "compile",
+                                cause: "TypeScript compilation timed out",
+                            }),
+                    })
+                )
+                .pipe(
+                    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) =>
+                    new FridaSessionError.FridaSessionError({
+                        cause,
+                        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({
+                            when: "message",
+                            cause: "Script destroyed",
+                        })
+                    )
+                );
+            };
+            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 error = new Error();
-                        error.name = "FridaScriptDefect";
-                        error.stack = message.stack ?? "";
-                        error.message = message.description.replace(/Error: /, "") ?? "";
-                        scriptDefectCause = error;
-                        const sessionError = new FridaSessionError.FridaSessionError({
-                            when: "message",
-                            cause: error.cause,
-                        });
-                        const asTake = Take.fail(sessionError);
-                        Queue.unsafeOffer(messageQueue, asTake);
+                        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: {
-                        const asTake = Take.of({ message: message.payload, data: Option.fromNullable(data) });
-                        Queue.unsafeOffer(messageQueue, asTake);
+                        mailbox.unsafeOffer({
+                            message: message.payload,
+                            data: Option.fromNullable(data),
+                        });
                         break;
                     }
 
-                    default:
-                        Function.absurd(message);
+                    default: {
+                        return Function.absurd(message);
+                    }
                 }
             };
-
-            const disconnectMessageHandler = Effect.sync(() => script.message.disconnect(messageHandler));
-            yield* Effect.addFinalizer(() => Effect.flatMap(messageQueue.shutdown, () => disconnectMessageHandler));
+            yield* Effect.addFinalizer(() => Effect.sync(() => script.message.disconnect(messageHandler)));
             script.message.connect(messageHandler);
 
-            const stream = Stream.fromQueue(messageQueue).pipe(Stream.flattenTake);
+            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",
+                }
+            );
+
             const sink = Sink.forEach<
-                { message: any; data: Option.Option<Buffer> },
+                { message: unknown; data: Option.Option<Buffer> },
                 void,
                 FridaSessionError.FridaSessionError,
                 never
-            >(({ data, message }) => {
-                if (Predicate.isNotUndefined(scriptDefectCause)) {
-                    return Effect.fail(
-                        new FridaSessionError.FridaSessionError({
-                            when: "rpcCall",
-                            cause: scriptDefectCause,
-                        })
-                    );
-                } else {
-                    return Effect.sync(() => script.post(message, Option.getOrNull(data)));
-                }
-            });
+            >(
+                Effect.fnUntraced(function* ({ data, message }) {
+                    yield* failIfDestroyed("message");
+                    yield* failIfScriptError("message");
+                    script.post(message, Option.getOrNull(data));
+                })
+            );
 
-            const destroyed = yield* Deferred.make<void, never>();
-            const destroyedHandler = () => Deferred.unsafeDone(destroyed, Effect.void);
-            script.destroyed.connect(destroyedHandler);
-
-            const callExport = (exportName: string) =>
+            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);
-
-                    const isDestroyed = yield* Deferred.isDone(destroyed);
-                    if (isDestroyed) {
-                        return yield* new FridaSessionError.FridaSessionError({
-                            when: "rpcCall",
-                            cause: "Script is destroyed",
-                        });
-                    }
-
-                    if (Predicate.isNotUndefined(scriptDefectCause)) {
-                        return yield* new FridaSessionError.FridaSessionError({
-                            when: "rpcCall",
-                            cause: scriptDefectCause,
-                        });
-                    }
-
+                    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 }),
                     });
-
                     yield* Effect.annotateCurrentSpan("result", result);
-                    return result;
+                    return yield* Schema.decodeUnknown(schema)(result);
                 });
 
             yield* Effect.tryPromise({
-                try: () => script.load(),
+                try: (signal) => {
+                    const cancellable = new Frida.Cancellable();
+                    signal.onabort = () => cancellable.cancel();
+                    return script.load(cancellable);
+                },
                 catch: (cause) => new FridaSessionError.FridaSessionError({ cause, when: "load" }),
             });
 
-            if (options?.resume === true) {
-                yield* Effect.tryPromise({
-                    try: () => device.resume(session.pid),
-                    catch: (cause) => new FridaSessionError.FridaSessionError({ cause, when: "resume" }),
-                });
-            }
-
             return {
                 sink,
-                script,
                 stream,
+                script,
                 destroyed,
                 callExport,
+                scriptError,
                 [FridaScriptTypeId]: FridaScriptTypeId,
             } as const;
         },
-        Effect.acquireRelease(({ script }: FridaScript.FridaScript) => Effect.promise(() => script.unload()))
+        Effect.acquireRelease(({ script }: FridaScript.FridaScript) =>
+            Effect.promise((signal) => {
+                const cancellable = new Frida.Cancellable();
+                signal.onabort = () => cancellable.cancel();
+                return script.unload(cancellable);
+            })
+        )
     )
 );
 
 /** @internal */
 export const layer = Function.dual<
     (
-        options?: (Frida.ScriptOptions & { readonly resume?: boolean | undefined }) | undefined
+        options?: FridaScript.LoadOptions | undefined
     ) => (
-        source: string | Buffer
-    ) => Layer.Layer<
-        FridaScript.FridaScript,
-        FridaSessionError.FridaSessionError,
-        FridaSession.FridaSession | FridaDevice.FridaDevice
-    >,
+        entrypoint: URL
+    ) => Layer.Layer<FridaScript.FridaScript, FridaSessionError.FridaSessionError, FridaSession.FridaSession>,
     (
-        source: string | Buffer,
-        options?: (Frida.ScriptOptions & { readonly resume?: boolean | undefined }) | undefined
-    ) => Layer.Layer<
-        FridaScript.FridaScript,
-        FridaSessionError.FridaSessionError,
-        FridaSession.FridaSession | FridaDevice.FridaDevice
-    >
+        entrypoint: URL,
+        options?: FridaScript.LoadOptions | undefined
+    ) => Layer.Layer<FridaScript.FridaScript, FridaSessionError.FridaSessionError, FridaSession.FridaSession>
 >(
-    (arguments_) => Predicate.isString(arguments_[0]),
-    (
-        source: string | Buffer,
-        options?: (Frida.ScriptOptions & { readonly resume?: boolean | undefined }) | undefined
-    ) => Layer.scoped(Tag, load(source, options))
+    (arguments_) => Predicate.hasProperty(arguments_[0], "href"),
+    (entrypoint: URL, options?: FridaScript.LoadOptions | undefined) =>
+        Layer.scoped(Tag, load(entrypoint, options)).pipe(Layer.provide(Path.layer))
 );