@efffrida/frida-tools 0.0.27 → 0.0.29

package/src/internal/session.ts

@@ -1,14 +1,17 @@
 import type * as Scope from "effect/Scope";
 
 import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Match from "effect/Match";
+import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
-import * as Frida from "frida";
 
 import type * as FridaSession from "../FridaSession.ts";
 
+import * as Frida from "frida";
+
 import * as FridaDevice from "../FridaDevice.ts";
 import * as FridaSessionError from "../FridaSessionError.ts";
 
@@ -18,12 +21,42 @@ export const FridaSessionTypeId: FridaSession.FridaSessionTypeId = Symbol.for(
 ) as FridaSession.FridaSessionTypeId;
 
 /** @internal */
-export const Tag = Context.GenericTag<FridaSession.FridaSession>("@efffrida/frida-tools/FridaSession");
+export const Tag = Context.Service<FridaSession.FridaSession>("@efffrida/frida-tools/FridaSession");
 
 /** @internal */
 export const isFridaSession = (u: unknown): u is FridaSession.FridaSession =>
     Predicate.hasProperty(u, FridaSessionTypeId);
 
+/** @internal */
+export const resume = (session: Frida.Session): Effect.Effect<void, FridaSessionError.FridaSessionError, never> =>
+    Effect.tryPromise({
+        try: (signal) => {
+            const cancellable = new Frida.Cancellable();
+            signal.onabort = () => cancellable.cancel();
+            return session.resume(cancellable);
+        },
+        catch: (cause) =>
+            new FridaSessionError.FridaSessionError({
+                when: "resume",
+                cause,
+            }),
+    });
+
+/** @internal */
+export const detach = (session: Frida.Session): Effect.Effect<void, FridaSessionError.FridaSessionError, never> =>
+    Effect.tryPromise({
+        try: (signal) => {
+            const cancellable = new Frida.Cancellable();
+            signal.onabort = () => cancellable.cancel();
+            return session.detach(cancellable);
+        },
+        catch: (cause) =>
+            new FridaSessionError.FridaSessionError({
+                when: "detach",
+                cause,
+            }),
+    });
+
 /** @internal */
 export const frontmost = (
     options?: Frida.FrontmostQueryOptions | undefined
@@ -35,7 +68,7 @@ export const frontmost = (
             return device.getFrontmostApplication(options, cancellable);
         })
     ).pipe(
-        Effect.flatMap(Effect.fromNullable),
+        Effect.flatMap(Effect.fromNullishOr),
         Effect.mapError(
             (cause) =>
                 new FridaSessionError.FridaSessionError({
@@ -50,7 +83,7 @@ export const spawn = (
     program: string | ReadonlyArray<string>,
     options?: Frida.SpawnOptions | undefined
 ): Effect.Effect<number, FridaSessionError.FridaSessionError, FridaDevice.FridaDevice | Scope.Scope> => {
-    const spawnEffect = Effect.flatMap(FridaDevice.FridaDevice, ({ device }) =>
+    const acquire = Effect.flatMap(FridaDevice.FridaDevice, ({ device }) =>
         Effect.tryPromise({
             try: (signal) => {
                 const cancellable = new Frida.Cancellable();
@@ -65,22 +98,6 @@ export const spawn = (
         })
     );
 
-    const resumeEffect = (pid: number) =>
-        Effect.flatMap(FridaDevice.FridaDevice, ({ device }) =>
-            Effect.tryPromise({
-                try: (signal) => {
-                    const cancellable = new Frida.Cancellable();
-                    signal.onabort = () => cancellable.cancel();
-                    return device.resume(pid, cancellable);
-                },
-                catch: (cause) =>
-                    new FridaSessionError.FridaSessionError({
-                        when: "resume",
-                        cause,
-                    }),
-            })
-        );
-
     const release = (pid: number) =>
         Effect.flatMap(FridaDevice.FridaDevice, ({ device }) =>
             Effect.promise((signal) => {
@@ -90,7 +107,6 @@ export const spawn = (
             })
         );
 
-    const acquire = Effect.tap(spawnEffect, resumeEffect);
     const resource = Effect.acquireRelease(acquire, release);
     return resource;
 };
@@ -104,6 +120,38 @@ export const attach = (
     FridaSessionError.FridaSessionError,
     FridaDevice.FridaDevice | Scope.Scope
 > => {
+    const detached = Deferred.makeUnsafe<
+        {
+            reason: Frida.SessionDetachReason;
+            crash: Option.Option<{
+                pid: number;
+                processName: string;
+                summary: string;
+                report: string;
+                parameters: unknown;
+            }>;
+        },
+        FridaSessionError.FridaSessionError
+    >();
+
+    const onDetached = (reason: Frida.SessionDetachReason, crash: Frida.Crash | null): void => {
+        Deferred.doneUnsafe(
+            detached,
+            Effect.succeed({
+                reason,
+                crash: Option.fromNullOr(crash).pipe(
+                    Option.map((c) => ({
+                        pid: c.pid,
+                        processName: c.processName,
+                        summary: c.summary,
+                        report: c.report,
+                        parameters: c.parameters,
+                    }))
+                ),
+            })
+        );
+    };
+
     const acquire = Effect.flatMap(FridaDevice.FridaDevice, ({ device }) =>
         Effect.tryPromise({
             try: (signal) => {
@@ -123,45 +171,45 @@ export const attach = (
         Effect.promise((signal) => {
             const cancellable = new Frida.Cancellable();
             signal.onabort = () => cancellable.cancel();
+            session.detached.disconnect(onDetached);
             return session.detach(cancellable);
         });
 
     const resource = Effect.acquireRelease(acquire, release);
-    return Effect.map(
-        resource,
-        (session) =>
-            ({
-                session,
-                resume: Effect.tryPromise((signal) => {
-                    const cancellable = new Frida.Cancellable();
-                    signal.onabort = () => cancellable.cancel();
-                    return session.resume(cancellable);
-                }),
-                enableChildGating: Effect.tryPromise((signal) => {
+    return Effect.map(resource, (session) => {
+        session.detached.connect(onDetached);
+
+        return {
+            session,
+            pid: session.pid,
+            detached: detached,
+            resume: resume(session),
+            detach: detach(session),
+            enableChildGating: Effect.tryPromise((signal) => {
+                const cancellable = new Frida.Cancellable();
+                signal.onabort = () => cancellable.cancel();
+                return session.enableChildGating(cancellable);
+            }),
+            disableChildGating: Effect.tryPromise((signal) => {
+                const cancellable = new Frida.Cancellable();
+                signal.onabort = () => cancellable.cancel();
+                return session.disableChildGating(cancellable);
+            }),
+            setupPeerConnection: (opts?: Frida.PeerOptions | undefined) =>
+                Effect.tryPromise((signal) => {
                     const cancellable = new Frida.Cancellable();
                     signal.onabort = () => cancellable.cancel();
-                    return session.enableChildGating(cancellable);
+                    return session.setupPeerConnection(opts, cancellable);
                 }),
-                disableChildGating: Effect.tryPromise((signal) => {
+            joinPortal: (address: string, opts?: Frida.PortalOptions | undefined) =>
+                Effect.tryPromise((signal) => {
                     const cancellable = new Frida.Cancellable();
                     signal.onabort = () => cancellable.cancel();
-                    return session.disableChildGating(cancellable);
+                    return session.joinPortal(address, opts, cancellable);
                 }),
-                setupPeerConnection: (opts?: Frida.PeerOptions | undefined) =>
-                    Effect.tryPromise((signal) => {
-                        const cancellable = new Frida.Cancellable();
-                        signal.onabort = () => cancellable.cancel();
-                        return session.setupPeerConnection(opts, cancellable);
-                    }),
-                joinPortal: (address: string, opts?: Frida.PortalOptions | undefined) =>
-                    Effect.tryPromise((signal) => {
-                        const cancellable = new Frida.Cancellable();
-                        signal.onabort = () => cancellable.cancel();
-                        return session.joinPortal(address, opts, cancellable);
-                    }),
-                [FridaSessionTypeId]: FridaSessionTypeId,
-            }) as const
-    );
+            [FridaSessionTypeId]: FridaSessionTypeId,
+        } as const;
+    });
 };
 
 /** @internal */
@@ -169,9 +217,11 @@ export const layer = (
     target: number | string | ReadonlyArray<string>,
     options?: (Frida.SpawnOptions & Frida.SessionOptions) | undefined
 ): Layer.Layer<FridaSession.FridaSession, FridaSessionError.FridaSessionError, FridaDevice.FridaDevice> =>
-    Layer.scoped(
+    Layer.effect(
         Tag,
         Effect.gen(function* () {
+            const { device } = yield* FridaDevice.FridaDevice;
+
             const pid = yield* Match.value(target).pipe(
                 Match.when(Match.number, (proc) => Effect.succeed(proc)),
                 Match.when(Match.string, (proc) => spawn(proc)),
@@ -179,6 +229,22 @@ export const layer = (
             );
 
             const session = yield* attach(pid, options);
+
+            if (typeof target !== "number") {
+                yield* Effect.tryPromise({
+                    try: (signal) => {
+                        const cancellable = new Frida.Cancellable();
+                        signal.onabort = () => cancellable.cancel();
+                        return device.resume(session.pid, cancellable);
+                    },
+                    catch: (cause) =>
+                        new FridaSessionError.FridaSessionError({
+                            when: "resume",
+                            cause,
+                        }),
+                });
+            }
+
             return session;
         })
     );
@@ -187,4 +253,4 @@ export const layer = (
 export const layerFrontmost = (
     options?: Frida.FrontmostQueryOptions | undefined
 ): Layer.Layer<FridaSession.FridaSession, FridaSessionError.FridaSessionError, FridaDevice.FridaDevice> =>
-    Layer.unwrapEffect(Effect.map(frontmost(options), (app) => layer(app.pid)));
+    Layer.unwrap(Effect.map(frontmost(options), (app) => layer(app.pid)));