SimlockDeviceHost.test.ts

import { describe, expect, it } from "@effect/vitest";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { SecretProviderId, type SimlockDeviceHostConfig } from "@t3tools/contracts";
import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver";
import * as HostProcess from "@t3tools/shared/HostProcess";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Deferred from "effect/Deferred";
import * as Exit from "effect/Exit";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
import * as Scope from "effect/Scope";
import * as TestClock from "effect/testing/TestClock";
import { HttpClient, HttpClientResponse } from "effect/http";
import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";

import * as ServerConfig from "../config.ts";
import * as ProcessRunner from "../processRunner.ts";
import * as SimlockDeviceHost from "./SimlockDeviceHost.ts";

const GATEWAY = "https://simlock.test:4700";

const config = (overrides: Partial<SimlockDeviceHostConfig> = {}): SimlockDeviceHostConfig => ({
  kind: "simlock",
  id: "pool",
  label: "Device pool",
  gatewayUrl: `${GATEWAY}/`,
  agentToken: "agent-token",
  maxLeases: 2,
  maxLeaseMinutes: 60,
  ...overrides,
});

const CATALOG = {
  platforms: [
    {
      platform: "ios",
      modelRuntimes: { "iPhone 17 Pro": ["27.0"], "Apple TV 4K": ["27.0"], "iPhone 12": [] },
      modelClasses: { "iPhone 17 Pro": "phone", "Apple TV 4K": "tv", "iPhone 12": "phone" },
    },
    {
      platform: "android",
      modelRuntimes: { "Pixel 9": ["36"], "Pixel 8": ["36"] },
      modelWorkers: { "Pixel 9": ["worker-a"], "Pixel 8": [] },
    },
  ],
};

/** The gateway's HTTP API and T3's agent-device CLI, recording what was asked of them. */
const fakePool = (
  options: {
    readonly failOpen?: boolean;
    readonly holdOpen?: {
      readonly entered: Deferred.Deferred<void>;
      readonly proceed: Deferred.Deferred<void>;
    };
  } = {},
) =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const path = yield* Path.Path;
    const requests: Array<string> = [];
    const commands: Array<{ readonly args: ReadonlyArray<string>; readonly cwd?: string }> = [];
    let leases = 0;
    let renewStatus = 200;
    let catalog: unknown = CATALOG;
    const http = HttpClient.make((request) =>
      Effect.sync(() => {
        const url = new URL(request.url);
        requests.push(`${request.method} ${url.pathname}`);
        const json = (body: unknown, status = 200) =>
          HttpClientResponse.fromWeb(request, Response.json(body, { status }));
        if (request.headers.authorization !== "Bearer agent-token")
          return json({ error: { code: "UNAUTHENTICATED", message: "Unknown bearer token" } }, 401);
        if (url.pathname === "/v1/catalog") return json(catalog);
        if (url.pathname.endsWith("/renew")) return json({}, renewStatus);
        if (request.method === "DELETE") return json({}, 202);
        return json({}, 404);
      }),
    );
    const runner = ProcessRunner.ProcessRunner.of({
      run: (input) =>
        Effect.gen(function* () {
          const args = input.args.slice(1);
          commands.push({ args, ...(input.cwd ? { cwd: input.cwd } : {}) });
          const command = args[0];
          const session = args[args.indexOf("--session") + 1]!;
          const configFile = args[args.indexOf("--config") + 1]!;
          const stateDir = (
            JSON.parse(yield* fs.readFileString(configFile)) as { stateDir: string }
          ).stateDir;
          if (command === "open") {
            if (options.failOpen) {
              return {
                stdout: JSON.stringify({
                  error: { message: "No device matches.", hint: "Retry." },
                }),
                stderr: "",
                code: ChildProcessSpawner.ExitCode(1),
                timedOut: false,
                stdoutTruncated: false,
                stderrTruncated: false,
                stdoutInvalidUtf8: false,
                stderrInvalidUtf8: false,
              };
            }
            if (options.holdOpen) {
              yield* Deferred.succeed(options.holdOpen.entered, undefined);
              yield* Deferred.await(options.holdOpen.proceed);
            }
            const dir = path.join(stateDir, "remote-connections");
            yield* fs.makeDirectory(dir, { recursive: true });
            yield* fs.writeFileString(
              path.join(dir, `${session}.json`),
              JSON.stringify({ leaseId: `lease-${++leases}` }),
            );
          }
          if (command === "screenshot") yield* fs.writeFile(args[1]!, new Uint8Array([1, 2, 3]));
          return {
            stdout: "{}",
            stderr: "",
            code: ChildProcessSpawner.ExitCode(0),
            timedOut: false,
            stdoutTruncated: false,
            stderrTruncated: false,
            stdoutInvalidUtf8: false,
            stderrInvalidUtf8: false,
          };
        }).pipe(Effect.orDie),
    });
    const ran = (command: string) => commands.filter(({ args }) => args[0] === command);
    return {
      http,
      runner,
      requests,
      ran,
      endLeases: () => {
        renewStatus = 404;
      },
      setCatalog: (next: unknown) => {
        catalog = next;
      },
    };
  });

const makeSecretResolver = (values: Record<string, string> = {}) =>
  Layer.succeed(SecretResolver.SecretResolver, {
    read: (references) =>
      Effect.succeed(references.map((reference) => values[reference.reference])),
    invalidate: () => Effect.void,
    label: (provider) => Effect.succeed(provider),
  });

const layerWith = (secrets: Layer.Layer<SecretResolver.SecretResolver>) =>
  Layer.mergeAll(
    ServerConfig.layerTest(process.cwd(), { prefix: "t3-simlock-host-" }),
    secrets,
  ).pipe(Layer.provideMerge(NodeServices.layer));

const layer = layerWith(makeSecretResolver());

const tokenSource = { provider: SecretProviderId.make("homelab"), reference: "simlock#token" };

const makeHost = (
  pool: Effect.Success<ReturnType<typeof fakePool>>,
  hostConfig: SimlockDeviceHostConfig,
  scope: Scope.Scope,
) =>
  SimlockDeviceHost.make(
    hostConfig,
    Effect.succeed({ nodePath: "node", entryPath: "/tools/agent-device.mjs" }),
  ).pipe(
    Effect.provideService(HttpClient.HttpClient, pool.http),
    Effect.provideService(ProcessRunner.ProcessRunner, pool.runner),
    Effect.provideService(Scope.Scope, scope),
  );

describe("Simlock device host", () => {
  it.effect("leases a pool device for agents and serves its screen and input to the panel", () =>
    Effect.gen(function* () {
      const pool = yield* fakePool();
      const fs = yield* FileSystem.FileSystem;
      const workspace = yield* fs.makeTempDirectoryScoped();
      const scope = yield* Scope.make();
      const host = yield* makeHost(pool, config(), scope);
      const ready = yield* host.ensureReady(() => Effect.void);

      const catalog = (yield* ready.devices.list).devices;
      // Only models a worker can make right now, and only phones and tablets.
      expect(catalog.map((device) => [device.id, device.version])).toEqual([
        ["simlock:ios:iPhone 17 Pro", "iOS 27.0"],
        ["simlock:android:Pixel 9", "Android 36"],
      ]);

      const leaseId = yield* ready.devices.boot(catalog[1]!, { workspaceRoot: workspace });
      expect(leaseId).toBe("lease-1");
      const [open] = pool.ran("open");
      expect(open?.args.slice(0, 5)).toEqual([
        "open",
        "--platform",
        "android",
        "--device",
        "Pixel 9",
      ]);
      expect(open?.cwd).toBe(yield* fs.realPath(workspace));
      expect(pool.ran("connect")[0]?.args).toContain(`${GATEWAY}/v1/agent-device`);

      const binding = yield* ready.devices.agentEndpoint!(leaseId);
      expect(binding).toMatchObject({
        baseUrl: `${GATEWAY}/v1/agent-device`,
        token: "agent-token",
        agentDeviceId: null,
        session: open?.args[open.args.indexOf("--session") + 1],
        installDirectory: yield* fs.realPath(workspace),
      });
      expect((yield* ready.devices.list).devices.at(-1)).toMatchObject({
        id: "lease-1",
        name: "Pixel 9",
        booted: true,
      });

      expect(
        yield* ready.upstream!(
          "/vendor/serve-sim/helper/lease-1/stream.avcc",
          new URLSearchParams(),
        ),
      ).toEqual({
        url: `${GATEWAY}/v1/leases/lease-1/stream`,
        headers: { authorization: "Bearer agent-token" },
        protocols: [],
      });
      expect(
        yield* ready.upstream!(
          "/vendor/serve-sim/helper/ws",
          new URLSearchParams({ device: "lease-1" }),
        ),
      ).toEqual({
        url: `${GATEWAY}/v1/leases/lease-1/input`,
        headers: { authorization: "Bearer agent-token" },
        protocols: [],
      });
      expect(
        yield* ready.upstream!("/vendor/serve-sim/helper/lease-1/config", new URLSearchParams()),
      ).toBeNull();
      expect(
        yield* ready.upstream!(
          "/vendor/serve-sim/helper/ws",
          new URLSearchParams({ device: "lease-2" }),
        ),
      ).toBeNull();
      expect([...(yield* ready.devices.screenshot({ ...catalog[1]!, id: leaseId }))]).toEqual([
        1, 2, 3,
      ]);

      yield* ready.devices.shutdown({ id: leaseId, platform: "android" });
      expect(pool.ran("close")).toHaveLength(1);
      expect((yield* ready.devices.list).devices.some((device) => device.booted)).toBe(false);
      yield* Scope.close(scope, Exit.void);
      expect(pool.ran("close")).toHaveLength(1);
    }).pipe(Effect.scoped, Effect.provide(layer)),
  );

  it.effect("caps leases at the limit", () =>
    Effect.gen(function* () {
      const pool = yield* fakePool();
      const scope = yield* Scope.make();
      const host = yield* makeHost(pool, config({ maxLeases: 1 }), scope);
      const ready = yield* host.ensureReady(() => Effect.void);
      const [iphone] = (yield* ready.devices.list).devices;
      yield* ready.devices.boot(iphone!);

      const refused = yield* ready.devices.boot(iphone!).pipe(Effect.flip);
      expect(refused.message).toContain("limited to 1 device");
      expect(pool.ran("open")).toHaveLength(1);
      yield* Scope.close(scope, Exit.void);
      expect(pool.ran("close")).toHaveLength(1);
    }).pipe(Effect.scoped, Effect.provide(layer)),
  );

  it.effect("reports its platforms unavailable when the gateway refuses the agent token", () =>
    Effect.gen(function* () {
      const pool = yield* fakePool();
      const scope = yield* Scope.make();
      const host = yield* makeHost(pool, config({ agentToken: "revoked" }), scope);
      expect(yield* host.platformAvailability("ios")).toEqual({
        platform: "ios",
        available: false,
        reason: "The Simlock gateway refused the agent token for Device pool.",
      });
      expect((yield* host.summary).platforms.every((platform) => !platform.available)).toBe(true);
      yield* Scope.close(scope, Exit.void);
    }).pipe(Effect.scoped, Effect.provide(layer)),
  );

  it.effect("sends saved and machine tokens only to the gateway each belongs to", () =>
    Effect.gen(function* () {
      const pool = yield* fakePool();
      const availability = (baseUrl: string) =>
        Effect.gen(function* () {
          const scope = yield* Scope.make();
          const host = yield* makeHost(pool, config({ agentToken: "" }), scope).pipe(
            Effect.provideService(HostProcess.Environment, {
              AGENT_DEVICE_DAEMON_BASE_URL: baseUrl,
              AGENT_DEVICE_DAEMON_AUTH_TOKEN: "agent-token",
            }),
          );
          const result = yield* host.platformAvailability("ios");
          yield* Scope.close(scope, Exit.void);
          return result;
        });

      expect(
        yield* SimlockDeviceHost.resolveSimlockToken(
          yield* SecretResolver.SecretResolver,
          "https://elsewhere.example:4700",
          config({ agentToken: "saved-token" }),
          {},
        ),
      ).toBeNull();

      expect(yield* availability(`${GATEWAY}/v1/agent-device`)).toEqual({
        platform: "ios",
        available: true,
      });
      const requests = pool.requests.length;
      expect(yield* availability("https://elsewhere.example:4700/v1/agent-device")).toEqual({
        platform: "ios",
        available: false,
        reason: "Add an agent token for Device pool in Settings.",
      });
      expect(pool.requests).toHaveLength(requests);
    }).pipe(Effect.scoped, Effect.provide(layer)),
  );

  it.effect("reads its agent token from the secret provider the setting names", () =>
    Effect.gen(function* () {
      const pool = yield* fakePool();
      const scope = yield* Scope.make();
      const host = yield* makeHost(pool, config({ agentToken: tokenSource }), scope);
      const ready = yield* host.ensureReady(() => Effect.void);
      const [iphone] = (yield* ready.devices.list).devices;
      const leaseId = yield* ready.devices.boot(iphone!);
      expect(yield* ready.devices.agentEndpoint!(leaseId)).toMatchObject({ token: "agent-token" });
      yield* Scope.close(scope, Exit.void);
      expect(pool.ran("close")).toHaveLength(1);
    }).pipe(
      Effect.scoped,
      Effect.provide(layerWith(makeSecretResolver({ "simlock#token": "agent-token" }))),
    ),
  );

  it.effect("fails instead of using this machine's token when its secret cannot be read", () =>
    Effect.gen(function* () {
      const pool = yield* fakePool();
      const scope = yield* Scope.make();
      const host = yield* makeHost(pool, config({ agentToken: tokenSource }), scope).pipe(
        Effect.provideService(HostProcess.Environment, {
          AGENT_DEVICE_DAEMON_BASE_URL: `${GATEWAY}/v1/agent-device`,
          AGENT_DEVICE_DAEMON_AUTH_TOKEN: "agent-token",
        }),
      );
      const availability = yield* host.platformAvailability("ios");
      expect(availability.available).toBe(false);
      expect(availability.reason).toContain('secret provider "homelab"');
      expect(pool.requests).toEqual([]);
      yield* Scope.close(scope, Exit.void);
    }).pipe(Effect.scoped, Effect.provide(layer)),
  );

  it.effect("lists a platform again as soon as its workers return", () =>
    Effect.gen(function* () {
      const pool = yield* fakePool();
      const scope = yield* Scope.make();
      const host = yield* makeHost(pool, config(), scope);
      const ready = yield* host.ensureReady(() => Effect.void);
      pool.setCatalog({ platforms: [] });
      expect((yield* ready.devices.list).devices).toEqual([]);
      // Mid-reconnect, the gateway knows the Android models but no worker that makes them.
      pool.setCatalog({
        platforms: [
          CATALOG.platforms[0]!,
          { ...CATALOG.platforms[1]!, modelWorkers: { "Pixel 9": [], "Pixel 8": [] } },
        ],
      });
      const during = (yield* ready.devices.list).devices;
      expect(during.some((device) => device.platform === "android")).toBe(false);
      pool.setCatalog(CATALOG);
      const after = (yield* ready.devices.list).devices;
      expect(after.some((device) => device.platform === "android")).toBe(true);
      yield* Scope.close(scope, Exit.void);
    }).pipe(Effect.scoped, Effect.provide(layer)),
  );

  it.effect("closes the session of a failed open so no lease is left behind", () =>
    Effect.gen(function* () {
      const pool = yield* fakePool({ failOpen: true });
      const scope = yield* Scope.make();
      const host = yield* makeHost(pool, config(), scope);
      const ready = yield* host.ensureReady(() => Effect.void);
      const [iphone] = (yield* ready.devices.list).devices;
      const failure = yield* ready.devices.boot(iphone!).pipe(Effect.flip);
      expect(String(failure.cause)).toContain("No device matches. Retry.");
      expect(pool.ran("close")).toHaveLength(1);
      // The failed open freed its slot.
      expect(yield* ready.devices.boot(iphone!).pipe(Effect.flip)).toBeDefined();
      yield* Scope.close(scope, Exit.void);
    }).pipe(Effect.scoped, Effect.provide(layer)),
  );

  it.effect("keeps a watched lease renewed and stops listing it once Simlock ends it", () =>
    Effect.gen(function* () {
      const pool = yield* fakePool();
      const scope = yield* Scope.make();
      const host = yield* makeHost(pool, config(), scope);
      const ready = yield* host.ensureReady(() => Effect.void);
      const [iphone] = (yield* ready.devices.list).devices;
      const leaseId = yield* ready.devices.boot(iphone!);

      yield* TestClock.adjust("2 minutes");
      expect(pool.requests).toContain(`POST /v1/leases/${leaseId}/renew`);
      expect((yield* ready.devices.list).devices.some((device) => device.id === leaseId)).toBe(
        true,
      );

      pool.endLeases();
      yield* TestClock.adjust("2 minutes");
      expect((yield* ready.devices.list).devices.some((device) => device.id === leaseId)).toBe(
        false,
      );
      yield* Scope.close(scope, Exit.void);
      expect(pool.ran("close")).toHaveLength(0);
    }).pipe(Effect.scoped, Effect.provide(layer)),
  );

  it.effect("returns a lease whose open finishes after the host stopped", () =>
    Effect.gen(function* () {
      const holdOpen = {
        entered: yield* Deferred.make<void>(),
        proceed: yield* Deferred.make<void>(),
      };
      const pool = yield* fakePool({ holdOpen });
      const host = yield* makeHost(pool, config(), yield* Scope.make());
      const ready = yield* host.ensureReady(() => Effect.void);
      const [iphone] = (yield* ready.devices.list).devices;
      const opening = yield* Effect.forkChild(ready.devices.boot(iphone!));
      yield* Deferred.await(holdOpen.entered);
      yield* host.stop;
      yield* Deferred.succeed(holdOpen.proceed, undefined);
      expect(Exit.isFailure(yield* Fiber.await(opening))).toBe(true);
      expect(pool.ran("close")).toHaveLength(1);
      expect((yield* ready.devices.list).devices.every((device) => !device.booted)).toBe(true);
    }).pipe(Effect.scoped, Effect.provide(layer)),
  );

  it.effect("holds a lease for its full maximum age, then returns it", () =>
    Effect.gen(function* () {
      const pool = yield* fakePool();
      const host = yield* makeHost(pool, config({ maxLeaseMinutes: 5 }), yield* Scope.make());
      const ready = yield* host.ensureReady(() => Effect.void);
      const [iphone] = (yield* ready.devices.list).devices;
      yield* ready.devices.boot(iphone!);

      yield* TestClock.adjust("299 seconds");
      expect(pool.ran("close")).toHaveLength(0);
      yield* TestClock.adjust("1 second");
      expect(pool.ran("close")).toHaveLength(1);
    }).pipe(Effect.scoped, Effect.provide(layer)),
  );
});