sailfork / t3code-github / apps/ desktop/ src/ preview/ BrowserImport/ Sources.test.ts

// @effect-diagnostics nodeBuiltinImport:off - Builds a Chromium-shaped cookie
// table with the same native bindings the source reads.
import * as NodePath from "node:path";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, describe, it } from "@effect/vitest";
import * as HostProcess from "@t3tools/shared/HostProcess";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Path from "effect/Path";
import * as Scope from "effect/Scope";
import { ChildProcessSpawner } from "effect/process";
import * as NodeSqlite from "node:sqlite";

import type { BrowserImportPathContext } from "./Sources.ts";
import {
  BROWSER_IMPORT_SOURCES,
  chromiumProcessIsAlive,
  chromiumSingletonLockIsHeld,
  firefoxSymlinkLockIsHeld,
  resolveCookieDatabase,
  isSourceInstalled,
  isSourceRunning,
  listSourceProfiles,
  sourcePathContext,
  windowsChromiumCookiesAreHeld,
} from "./Sources.ts";
import { symlinksSupported } from "@t3tools/shared/testing/symlinks";

const helium = BROWSER_IMPORT_SOURCES.find((source) => source.id === "helium")!;

const withSourceHome = Effect.fnUntraced(function* () {
  const fileSystem = yield* FileSystem.FileSystem;
  const home = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3code-sources-" });
  const context = yield* sourcePathContext.pipe(
    Effect.provideService(HostProcess.Environment, { HOME: home }),
    Effect.provideService(HostProcess.Platform, "darwin"),
  );
  yield* fileSystem.makeDirectory(userDataDirectory(context), { recursive: true });
  return context;
});

const userDataDirectory = (context: BrowserImportPathContext) => {
  const root = helium.userDataDirectory(context);
  if (root === undefined) throw new Error("Helium has no macOS user-data directory");
  return root;
};

const run = <A, E>(
  effect: Effect.Effect<
    A,
    E,
    FileSystem.FileSystem | Path.Path | Scope.Scope | ChildProcessSpawner.ChildProcessSpawner
  >,
) => effect.pipe(Effect.provide(NodeServices.layer), Effect.scoped);

const writeCookieDatabase = (file: string, count: number) =>
  Effect.sync(() => {
    const database = new NodeSqlite.DatabaseSync(file);
    database.exec("create table cookies (host_key text, name text)");
    const insert = database.prepare("insert into cookies (host_key, name) values (?, ?)");
    for (let index = 0; index < count; index += 1) insert.run("example.test", `c${index}`);
    database.close();
  });

const writeFirefoxCookieDatabase = (
  file: string,
  defaultContainerCount: number,
  containerCount: number,
) =>
  Effect.sync(() => {
    const database = new NodeSqlite.DatabaseSync(file);
    database.exec("create table moz_cookies (originAttributes text not null)");
    const insert = database.prepare("insert into moz_cookies (originAttributes) values (?)");
    for (let index = 0; index < defaultContainerCount; index += 1) insert.run("");
    for (let index = 0; index < containerCount; index += 1) insert.run("^userContextId=2");
    database.close();
  });

describe("isSourceRunning", () => {
  it.effect("uses the held cookie database as Chromium's Windows running signal", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const home = yield* fileSystem.makeTempDirectoryScoped({
          prefix: "t3code-helium-windows-lock-",
        });
        const context = yield* sourcePathContext.pipe(
          Effect.provideService(HostProcess.Environment, {
            HOME: home,
            LOCALAPPDATA: home,
          }),
          Effect.provideService(HostProcess.Platform, "win32"),
        );
        const profile = context.path.join(helium.userDataDirectory(context)!, "Default");
        const database = context.path.join(profile, "Network", "Cookies");
        yield* fileSystem.makeDirectory(context.path.join(profile, "Network"), { recursive: true });
        yield* writeCookieDatabase(database, 1);

        const probed: string[] = [];
        assert.isTrue(
          yield* windowsChromiumCookiesAreHeld(helium, context, (path) =>
            Effect.sync(() => {
              probed.push(path);
              return true;
            }),
          ),
        );
        assert.deepEqual(probed, [database]);
      }),
    ),
  );

  it.effect.skipIf(!symlinksSupported)(
    "reads Chromium's dangling SingletonLock symlink as a running browser",
    () =>
      run(
        Effect.gen(function* () {
          const fileSystem = yield* FileSystem.FileSystem;
          const context = yield* withSourceHome();
          assert.isFalse(yield* isSourceRunning(helium, context));

          yield* fileSystem.symlink(
            "host-that-does-not-exist-1234",
            `${userDataDirectory(context)}/SingletonLock`,
          );

          assert.isTrue(yield* isSourceRunning(helium, context));
        }),
      ),
  );
});

describe("chromiumSingletonLockIsHeld", () => {
  it.effect("ignores a positively dead PID on the current host", () =>
    Effect.gen(function* () {
      const checked: number[] = [];
      const held = yield* chromiumSingletonLockIsHeld("current-host-4321", "current-host", (pid) =>
        Effect.sync(() => {
          checked.push(pid);
          return false;
        }),
      );
      assert.isFalse(held);
      assert.deepEqual(checked, [4321]);
    }),
  );

  it.effect("keeps foreign-host and malformed targets without probing a PID", () =>
    Effect.gen(function* () {
      let probes = 0;
      const probe = (_pid: number) =>
        Effect.sync(() => {
          probes += 1;
          return false;
        });
      assert.isTrue(yield* chromiumSingletonLockIsHeld("another-host-4321", "current-host", probe));
      assert.isTrue(
        yield* chromiumSingletonLockIsHeld("current-host-no-pid", "current-host", probe),
      );
      assert.isTrue(yield* chromiumSingletonLockIsHeld("current-host-0", "current-host", probe));
      assert.strictEqual(probes, 0);
    }),
  );
});

describe("chromiumProcessIsAlive", () => {
  it.effect("returns false only when signal 0 reports a missing process", () =>
    Effect.gen(function* () {
      const missing = Object.assign(new Error("missing"), { code: "ESRCH" });
      const denied = Object.assign(new Error("denied"), { code: "EPERM" });
      assert.isFalse(
        yield* chromiumProcessIsAlive(4321, () => {
          throw missing;
        }),
      );
      assert.isTrue(
        yield* chromiumProcessIsAlive(4321, () => {
          throw denied;
        }),
      );
      assert.isTrue(
        yield* chromiumProcessIsAlive(4321, () => {
          throw undefined;
        }),
      );
      assert.isTrue(
        yield* chromiumProcessIsAlive(4321, () => {
          throw "unknown failure";
        }),
      );
      assert.isTrue(
        yield* chromiumProcessIsAlive(4321, () => {
          throw null;
        }),
      );
      assert.isTrue(yield* chromiumProcessIsAlive(4321, () => true));
    }),
  );
});

describe("isSourceInstalled", () => {
  it.effect("ignores a user-data directory that holds no cookie database", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const context = yield* withSourceHome();
        const root = userDataDirectory(context);

        yield* fileSystem.makeDirectory(`${root}/NativeMessagingHosts`, { recursive: true });
        assert.isFalse(yield* isSourceInstalled(helium, context));

        yield* fileSystem.makeDirectory(`${root}/Default`, { recursive: true });
        yield* fileSystem.writeFileString(`${root}/Default/Cookies`, "db");
        assert.isTrue(yield* isSourceInstalled(helium, context));

        yield* fileSystem.remove(`${root}/Default`, { recursive: true });
        yield* fileSystem.makeDirectory(`${root}/Profile 1`, { recursive: true });
        yield* fileSystem.writeFileString(`${root}/Profile 1/Cookies`, "db");
        assert.isTrue(yield* isSourceInstalled(helium, context));

        yield* fileSystem.remove(root, { recursive: true });
        assert.isFalse(yield* isSourceInstalled(helium, context));
      }),
    ),
  );
});

describe("listSourceProfiles", () => {
  it.effect("reads the profile names the browser shows", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const context = yield* withSourceHome();
        yield* fileSystem.writeFileString(
          `${userDataDirectory(context)}/Local State`,
          `{"profile":{"info_cache":{"Default":{"name":"You"},"Profile 2":{"name":"  "}}}}`,
        );

        assert.deepEqual(yield* listSourceProfiles(helium, context), [
          { directory: "Default", name: "You" },
          { directory: "Profile 2", name: "Profile 2" },
        ]);
      }),
    ),
  );

  it.effect("scans for profiles when Local State is malformed", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const context = yield* withSourceHome();
        const root = userDataDirectory(context);
        yield* fileSystem.writeFileString(`${root}/Local State`, "{not-json");
        yield* fileSystem.makeDirectory(`${root}/Default`, { recursive: true });
        yield* fileSystem.writeFileString(`${root}/Default/Cookies`, "db");

        assert.deepEqual(yield* listSourceProfiles(helium, context), [
          { directory: "Default", name: "Default" },
        ]);
      }),
    ),
  );

  it.effect("discovers profiles with cookies under Network/ (Chromium 127+)", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const context = yield* withSourceHome();
        const root = userDataDirectory(context);
        yield* fileSystem.makeDirectory(`${root}/Default/Network`, { recursive: true });
        yield* fileSystem.writeFileString(`${root}/Default/Network/Cookies`, "db");

        assert.deepEqual(yield* listSourceProfiles(helium, context), [
          { directory: "Default", name: "Default" },
        ]);
      }),
    ),
  );

  it.effect("falls through to the legacy database when Network/Cookies is a directory", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const paths = yield* withSourceHome();
        const root = helium.userDataDirectory(paths);
        yield* fileSystem.makeDirectory(`${root}/Default/Network/Cookies`, { recursive: true });
        yield* writeCookieDatabase(`${root}/Default/Cookies`, 2);

        const [profile] = yield* listSourceProfiles(helium, paths);
        assert.equal(profile?.directory, "Default");
        assert.equal(profile?.cookieCount, 2);
      }),
    ),
  );
});

describe("cookieDatabaseCandidatePaths", () => {
  it.effect("resolves the live Network/ jar over a leftover root Cookies", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const context = yield* withSourceHome();
        const root = userDataDirectory(context);
        yield* fileSystem.makeDirectory(`${root}/Default/Network`, { recursive: true });
        yield* fileSystem.writeFileString(`${root}/Default/Network/Cookies`, "live");
        yield* fileSystem.writeFileString(`${root}/Default/Cookies`, "stale");

        assert.equal(
          yield* resolveCookieDatabase(helium, context, "Default"),
          context.path.join(root, "Default", "Network", "Cookies"),
        );
        yield* fileSystem.remove(`${root}/Default/Cookies`);
        assert.isTrue(yield* isSourceInstalled(helium, context));
      }),
    ),
  );
});

const firefox = BROWSER_IMPORT_SOURCES.find((source) => source.id === "firefox")!;

const zen = BROWSER_IMPORT_SOURCES.find((source) => source.id === "zen")!;

describe("Zen", () => {
  it.effect("resolves Zen's native user-data roots on every supported platform", () =>
    run(
      Effect.gen(function* () {
        const darwinContext = yield* sourcePathContext.pipe(
          Effect.provideService(HostProcess.Environment, { HOME: "/Users/zen-user" }),
          Effect.provideService(HostProcess.Platform, "darwin"),
        );
        const windowsContext = yield* sourcePathContext.pipe(
          Effect.provideService(HostProcess.Environment, {
            HOME: "C:\\Users\\zen-user",
            APPDATA: "C:\\Users\\zen-user\\AppData\\Roaming",
          }),
          Effect.provideService(HostProcess.Platform, "win32"),
        );
        const linuxContext = yield* sourcePathContext.pipe(
          Effect.provideService(HostProcess.Environment, { HOME: "/home/zen-user" }),
          Effect.provideService(HostProcess.Platform, "linux"),
        );

        assert.equal(zen.name, "Zen");
        assert.equal(zen.engine, "firefox");
        assert.deepEqual([...zen.platforms], ["darwin", "win32", "linux"]);
        assert.equal(
          zen.userDataDirectory(darwinContext),
          darwinContext.path.join("/Users/zen-user", "Library", "Application Support", "zen"),
        );
        assert.equal(
          zen.userDataDirectory(windowsContext),
          windowsContext.path.join("C:\\Users\\zen-user\\AppData\\Roaming", "zen"),
        );
        assert.equal(
          zen.userDataDirectory(linuxContext),
          linuxContext.path.join("/home/zen-user", ".config", "zen"),
        );
        assert.deepEqual(zen.alternateLinuxRoots?.(linuxContext), [
          linuxContext.path.join("/home/zen-user", ".zen"),
          linuxContext.path.join("/home/zen-user", ".var", "app", "app.zen_browser.zen", "zen"),
        ]);
      }),
    ),
  );

  it.effect("discovers Zen profiles through its Firefox-compatible metadata", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const home = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3code-zen-" });
        const context = yield* sourcePathContext.pipe(
          Effect.provideService(HostProcess.Environment, { HOME: home }),
          Effect.provideService(HostProcess.Platform, "darwin"),
        );
        const root = zen.userDataDirectory(context)!;
        yield* fileSystem.makeDirectory(root, { recursive: true });
        const profile = context.path.join(root, "Profiles", "zen.default");
        yield* fileSystem.makeDirectory(profile, { recursive: true });
        yield* writeFirefoxCookieDatabase(context.path.join(profile, "cookies.sqlite"), 2, 1);
        yield* fileSystem.makeDirectory(context.path.join(root, "Profiles", "empty.default"), {
          recursive: true,
        });
        yield* fileSystem.writeFileString(
          context.path.join(root, "profiles.ini"),
          [
            "[Profile0]",
            "Name=Zen",
            "IsRelative=1",
            "Path=Profiles/zen.default",
            "ZenAvatarPath=chrome://browser/content/zen-avatars/avatar-55.svg",
            "Default=1",
            "",
            "[Profile1]",
            "Name=Empty",
            "IsRelative=1",
            "Path=Profiles/empty.default",
            "",
          ].join("\n"),
        );

        assert.deepEqual(yield* listSourceProfiles(zen, context), [
          {
            directory: context.path.join("Profiles", "zen.default"),
            name: "Zen",
            cookieCount: 2,
          },
        ]);
        assert.isTrue(yield* isSourceInstalled(zen, context));
        assert.isFalse(yield* isSourceRunning(zen, context));
        assert.equal(
          yield* resolveCookieDatabase(zen, context, context.path.join("Profiles", "zen.default")),
          context.path.join(profile, "cookies.sqlite"),
        );
      }),
    ),
  );

  it.effect("discovers Zen profiles in both current and legacy Linux roots", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const home = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3code-zen-linux-" });
        const context = yield* sourcePathContext.pipe(
          Effect.provideService(HostProcess.Environment, { HOME: home }),
          Effect.provideService(HostProcess.Platform, "linux"),
        );
        const currentRoot = context.path.join(home, ".config", "zen");
        const legacyRoot = context.path.join(home, ".zen");
        const currentProfile = context.path.join(currentRoot, "current.default");
        const legacyProfile = context.path.join(legacyRoot, "legacy.default");

        for (const [root, profile, name] of [
          [currentRoot, currentProfile, "Current"],
          [legacyRoot, legacyProfile, "Legacy"],
        ] as const) {
          yield* fileSystem.makeDirectory(profile, { recursive: true });
          yield* writeFirefoxCookieDatabase(context.path.join(profile, "cookies.sqlite"), 1, 0);
          yield* fileSystem.writeFileString(
            context.path.join(root, "profiles.ini"),
            [
              "[Profile0]",
              `Name=${name}`,
              "IsRelative=1",
              `Path=${context.path.basename(profile)}`,
            ].join("\n"),
          );
        }

        assert.deepEqual(yield* listSourceProfiles(zen, context), [
          { directory: "current.default", name: "Current", cookieCount: 1 },
          { directory: legacyProfile, name: "Legacy", cookieCount: 1 },
        ]);
        assert.isTrue(yield* isSourceInstalled(zen, context));
        assert.equal(
          yield* resolveCookieDatabase(zen, context, legacyProfile),
          context.path.join(legacyProfile, "cookies.sqlite"),
        );

        yield* fileSystem.writeFileString(
          context.path.join(currentRoot, "profiles.ini"),
          `[Profile0]\nName=Shared\nIsRelative=0\nPath=${legacyProfile}\n`,
        );
        assert.deepEqual(yield* listSourceProfiles(zen, context), [
          { directory: legacyProfile, name: "Shared", cookieCount: 1 },
        ]);

        yield* fileSystem.remove(currentRoot, { recursive: true });
        assert.isTrue(yield* isSourceInstalled(zen, context));
        assert.deepEqual(yield* listSourceProfiles(zen, context), [
          { directory: legacyProfile, name: "Legacy", cookieCount: 1 },
        ]);
      }),
    ),
  );

  it.effect("discovers a Flatpak-only Zen installation and resolves its cookies", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const home = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3code-zen-flatpak-" });
        const context = yield* sourcePathContext.pipe(
          Effect.provideService(HostProcess.Environment, { HOME: home }),
          Effect.provideService(HostProcess.Platform, "linux"),
        );
        const root = context.path.join(home, ".var", "app", "app.zen_browser.zen", "zen");
        const profile = context.path.join(root, "flatpak.default");
        yield* fileSystem.makeDirectory(profile, { recursive: true });
        yield* writeFirefoxCookieDatabase(context.path.join(profile, "cookies.sqlite"), 2, 1);
        yield* fileSystem.writeFileString(
          context.path.join(root, "profiles.ini"),
          "[Profile0]\nName=Flatpak\nIsRelative=1\nPath=flatpak.default\n",
        );

        assert.deepEqual(yield* listSourceProfiles(zen, context), [
          { directory: profile, name: "Flatpak", cookieCount: 2 },
        ]);
        assert.isTrue(yield* isSourceInstalled(zen, context));
        assert.equal(
          yield* resolveCookieDatabase(zen, context, profile),
          context.path.join(profile, "cookies.sqlite"),
        );
      }),
    ),
  );

  it.effect("does not mistake Firefox Snap installs for Zen profiles", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const home = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3code-zen-snap-" });
        const context = yield* sourcePathContext.pipe(
          Effect.provideService(HostProcess.Environment, { HOME: home }),
          Effect.provideService(HostProcess.Platform, "linux"),
        );
        const zenRoot = context.path.join(home, ".config", "zen");
        const snapRoot = context.path.join(
          home,
          "snap",
          "firefox",
          "common",
          ".mozilla",
          "firefox",
        );
        const zenProfile = context.path.join(zenRoot, "zen.default");
        const snapProfile = context.path.join(snapRoot, "snap.default");
        for (const root of [zenRoot, snapRoot]) {
          const profile = root === zenRoot ? zenProfile : snapProfile;
          yield* fileSystem.makeDirectory(profile, { recursive: true });
          yield* writeFirefoxCookieDatabase(context.path.join(profile, "cookies.sqlite"), 1, 0);
          yield* fileSystem.writeFileString(
            context.path.join(root, "profiles.ini"),
            [
              "[Profile0]",
              "Name=Personal",
              "IsRelative=1",
              `Path=${profile === zenProfile ? "zen.default" : "snap.default"}`,
            ].join("\n"),
          );
        }

        const profiles = yield* listSourceProfiles(zen, context);
        assert.deepEqual(
          profiles.map((profile) => profile.directory),
          ["zen.default"],
        );
        assert.isTrue(yield* isSourceInstalled(zen, context));
      }),
    ),
  );
});

describe("Firefox Snap profiles", () => {
  it.effect.skipIf(!symlinksSupported)(
    "finds Snap profiles with or without profiles.ini and checks their locks",
    () =>
      run(
        Effect.gen(function* () {
          const fileSystem = yield* FileSystem.FileSystem;
          const home = yield* fileSystem.makeTempDirectoryScoped({
            prefix: "t3code-firefox-snap-",
          });
          const context = yield* sourcePathContext.pipe(
            Effect.provideService(HostProcess.Environment, { HOME: home }),
            Effect.provideService(HostProcess.Platform, "linux"),
          );
          const root = context.path.join(home, "snap", "firefox", "common", ".mozilla", "firefox");
          const directory = context.path.join(root, "abcd.default");
          yield* fileSystem.makeDirectory(directory, { recursive: true });
          yield* writeFirefoxCookieDatabase(`${directory}/cookies.sqlite`, 2, 1);
          yield* fileSystem.writeFileString(
            `${root}/profiles.ini`,
            "[Profile0]\nName=Personal\nIsRelative=1\nPath=abcd.default\n",
          );

          assert.isTrue(yield* isSourceInstalled(firefox, context));
          assert.deepEqual(yield* listSourceProfiles(firefox, context), [
            { directory, name: "Personal", cookieCount: 2 },
          ]);
          assert.equal(
            yield* resolveCookieDatabase(firefox, context, directory),
            context.path.join(directory, "cookies.sqlite"),
          );
          assert.isFalse(yield* isSourceRunning(firefox, context));
          yield* fileSystem.symlink("foreign-host:+4242", `${directory}/lock`);
          assert.isTrue(yield* isSourceRunning(firefox, context));
          yield* fileSystem.remove(`${directory}/lock`);
          assert.isFalse(yield* isSourceRunning(firefox, context));

          yield* fileSystem.remove(`${root}/profiles.ini`);
          assert.deepEqual(yield* listSourceProfiles(firefox, context), [
            { directory, name: "abcd.default", cookieCount: 2 },
          ]);
        }),
      ),
  );

  it.effect("keeps matching profile names in native and Snap installs distinct", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const home = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3code-firefox-snap-" });
        const context = yield* sourcePathContext.pipe(
          Effect.provideService(HostProcess.Environment, { HOME: home }),
          Effect.provideService(HostProcess.Platform, "linux"),
        );
        const native = context.path.join(home, ".mozilla", "firefox");
        const snap = context.path.join(home, "snap", "firefox", "common", ".mozilla", "firefox");
        for (const root of [native, snap]) {
          yield* fileSystem.makeDirectory(`${root}/abcd.default`, { recursive: true });
          yield* writeFirefoxCookieDatabase(`${root}/abcd.default/cookies.sqlite`, 1, 0);
          yield* fileSystem.writeFileString(
            `${root}/profiles.ini`,
            "[Profile0]\nName=Personal\nIsRelative=1\nPath=abcd.default\n" +
              `[Profile1]\nName=Shared\nIsRelative=0\nPath=${snap}/abcd.default\n`,
          );
        }

        const profiles = yield* listSourceProfiles(firefox, context);
        assert.deepEqual(
          profiles.map((profile) => profile.directory),
          ["abcd.default", context.path.join(snap, "abcd.default")],
        );
        const databases = yield* Effect.forEach(profiles, (profile) =>
          resolveCookieDatabase(firefox, context, profile.directory),
        );
        assert.deepEqual(databases, [
          context.path.join(native, "abcd.default", "cookies.sqlite"),
          context.path.join(snap, "abcd.default", "cookies.sqlite"),
        ]);
      }),
    ),
  );
});

describe("listSourceProfiles Firefox fallback", () => {
  const cases = [
    { platform: "linux" as const, profileDirectory: "linux.default" },
    { platform: "darwin" as const, profileDirectory: NodePath.join("Profiles", "macos.default") },
    { platform: "win32" as const, profileDirectory: NodePath.join("Profiles", "windows.default") },
  ];

  it.effect.each(cases)(
    "scans the $platform profile location and excludes stale entries",
    ({ platform, profileDirectory }) =>
      run(
        Effect.gen(function* () {
          const fileSystem = yield* FileSystem.FileSystem;
          const path = yield* Path.Path;
          const home = yield* fileSystem.makeTempDirectoryScoped({
            prefix: `t3code-firefox-${platform}-`,
          });
          const appData = path.join(home, "AppData", "Roaming");
          const context = yield* sourcePathContext.pipe(
            Effect.provideService(HostProcess.Environment, {
              HOME: home,
              APPDATA: appData,
            }),
            Effect.provideService(HostProcess.Platform, platform),
          );
          const root = firefox.userDataDirectory(context)!;
          const scanRoot = platform === "linux" ? root : path.join(root, "Profiles");
          yield* fileSystem.makeDirectory(path.join(root, profileDirectory), { recursive: true });
          yield* fileSystem.writeFileString(
            path.join(root, profileDirectory, "cookies.sqlite"),
            "db",
          );
          yield* fileSystem.makeDirectory(path.join(scanRoot, "stale.default"), {
            recursive: true,
          });
          yield* fileSystem.writeFileString(path.join(scanRoot, "stale-file.default"), "not-dir");

          assert.deepEqual(yield* listSourceProfiles(firefox, context), [
            {
              directory: profileDirectory,
              name: path.basename(profileDirectory),
            },
          ]);
        }),
      ),
  );

  it.effect("scans for profiles when profiles.ini declares only ones without cookies", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        const home = yield* fileSystem.makeTempDirectoryScoped({
          prefix: "t3code-firefox-stale-ini-",
        });
        const context = yield* sourcePathContext.pipe(
          Effect.provideService(HostProcess.Environment, { HOME: home }),
          Effect.provideService(HostProcess.Platform, "darwin"),
        );
        const root = firefox.userDataDirectory(context)!;
        yield* fileSystem.makeDirectory(path.join(root, "Profiles", "stale.default"), {
          recursive: true,
        });
        const realDirectory = path.join(root, "Profiles", "real.default");
        yield* fileSystem.makeDirectory(realDirectory, { recursive: true });
        yield* writeFirefoxCookieDatabase(path.join(realDirectory, "cookies.sqlite"), 3, 0);
        yield* fileSystem.writeFileString(
          path.join(root, "profiles.ini"),
          ["[Profile0]", "Name=Stale", "IsRelative=1", "Path=Profiles/stale.default"].join("\n"),
        );

        assert.deepEqual(yield* listSourceProfiles(firefox, context), [
          {
            directory: path.join("Profiles", "real.default"),
            name: "real.default",
            cookieCount: 3,
          },
        ]);
        assert.isTrue(yield* isSourceInstalled(firefox, context));
      }),
    ),
  );

  it.effect("counts only importable cookies for declared and fallback profiles", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        const home = yield* fileSystem.makeTempDirectoryScoped({
          prefix: "t3code-firefox-counts-",
        });
        const context = yield* sourcePathContext.pipe(
          Effect.provideService(HostProcess.Environment, { HOME: home }),
          Effect.provideService(HostProcess.Platform, "darwin"),
        );
        const root = firefox.userDataDirectory(context)!;
        const declaredDirectory = path.join(root, "Profiles", "declared.default");
        yield* fileSystem.makeDirectory(declaredDirectory, { recursive: true });
        yield* writeFirefoxCookieDatabase(path.join(declaredDirectory, "cookies.sqlite"), 2, 3);
        yield* fileSystem.writeFileString(
          path.join(root, "profiles.ini"),
          ["[Profile0]", "Name=Declared", "IsRelative=1", "Path=Profiles/declared.default"].join(
            "\n",
          ),
        );

        assert.deepEqual(yield* listSourceProfiles(firefox, context), [
          {
            directory: path.join("Profiles", "declared.default"),
            name: "Declared",
            cookieCount: 2,
          },
        ]);

        yield* fileSystem.remove(path.join(root, "profiles.ini"));
        const fallbackDirectory = path.join(root, "Profiles", "fallback.default");
        yield* fileSystem.makeDirectory(fallbackDirectory, { recursive: true });
        yield* writeFirefoxCookieDatabase(path.join(fallbackDirectory, "cookies.sqlite"), 1, 4);

        assert.deepEqual(yield* listSourceProfiles(firefox, context), [
          {
            directory: path.join("Profiles", "declared.default"),
            name: "declared.default",
            cookieCount: 2,
          },
          {
            directory: path.join("Profiles", "fallback.default"),
            name: "fallback.default",
            cookieCount: 1,
          },
        ]);
      }),
    ),
  );
});

describe("isSourceRunning for Firefox", () => {
  it.effect.skipIf(!symlinksSupported)("finds the lock inside the profile, not at the root", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const home = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3code-firefox-" });
        const context = yield* sourcePathContext.pipe(
          Effect.provideService(HostProcess.Environment, { HOME: home }),
          Effect.provideService(HostProcess.Platform, "darwin"),
        );
        const root = firefox.userDataDirectory(context)!;
        const profile = `${root}/Profiles/abcd.default-release`;
        yield* fileSystem.makeDirectory(profile, { recursive: true });
        yield* fileSystem.writeFileString(`${profile}/cookies.sqlite`, "db");

        assert.isFalse(yield* isSourceRunning(firefox, context));

        yield* fileSystem.writeFileString(`${root}/lock`, "");
        assert.isFalse(yield* isSourceRunning(firefox, context));

        yield* fileSystem.writeFileString(`${profile}/.parentlock`, "");
        assert.isFalse(yield* isSourceRunning(firefox, context));

        yield* fileSystem.symlink(`127.0.0.1:+${process.pid}`, `${profile}/lock`);
        assert.isTrue(yield* isSourceRunning(firefox, context));
      }),
    ),
  );

  it.effect("reads a Firefox lock symlink's pid to tell live from crashed", () =>
    Effect.gen(function* () {
      const alive = (pid: number) => Effect.succeed(pid === 4242);
      const local = new Set(["127.0.0.1", "127.0.1.1", "192.168.1.20"]);
      assert.isTrue(yield* firefoxSymlinkLockIsHeld("127.0.0.1:4242", local, alive));
      assert.isTrue(yield* firefoxSymlinkLockIsHeld("127.0.1.1:+4242", local, alive));
      assert.isTrue(yield* firefoxSymlinkLockIsHeld("192.168.1.20:+4242", local, alive));
      assert.isFalse(yield* firefoxSymlinkLockIsHeld("127.0.0.1:+9999", local, alive));
      assert.isFalse(yield* firefoxSymlinkLockIsHeld("192.168.1.20:+9999", local, alive));
      assert.isTrue(yield* firefoxSymlinkLockIsHeld("garbage", local, alive));
      assert.isTrue(yield* firefoxSymlinkLockIsHeld("10.0.0.7:+9999", local, alive));
    }),
  );

  it.effect("does not treat a stale parent.lock file as a running browser", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const home = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3code-firefox-" });
        const context = yield* sourcePathContext.pipe(
          // Without APPDATA, the Windows Firefox fixture would escape into the repo.
          Effect.provideService(HostProcess.Environment, {
            HOME: home,
            APPDATA: `${home}/AppData/Roaming`,
          }),
          Effect.provideService(HostProcess.Platform, "win32"),
        );
        const root = firefox.userDataDirectory(context)!;
        const profile = `${root}/Profiles/gx7x7fqx.default-release`;
        yield* fileSystem.makeDirectory(profile, { recursive: true });
        yield* fileSystem.writeFileString(`${profile}/cookies.sqlite`, "db");

        yield* fileSystem.writeFileString(`${profile}/parent.lock`, "");
        assert.isFalse(yield* isSourceRunning(firefox, context));
      }),
    ),
  );
});

describe("listSourceProfiles hardening", () => {
  it.effect("drops profile directories that are not a single plain segment", () =>
    run(
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const context = yield* withSourceHome();
        yield* fileSystem.writeFileString(
          `${userDataDirectory(context)}/Local State`,
          `{"profile":{"info_cache":{"Default":{"name":"You"},"../../../../secrets":{"name":"Escape"},"a/b":{"name":"Nested"},"..":{"name":"Parent"}}}}`,
        );

        const profiles = yield* listSourceProfiles(helium, context);

        assert.deepEqual(
          profiles.map((profile) => profile.directory),
          ["Default"],
        );
      }),
    ),
  );
});

describe("Safari profiles", () => {
  const safari = BROWSER_IMPORT_SOURCES.find((source) => source.id === "safari")!;
  const workUuid = "C561D071-67AD-4537-866F-54F65FB8E8DD";
  const otherUuid = "2875EB19-B938-4E38-BE92-5AE97C256BDD";

  const fixture = Effect.fnUntraced(function* () {
    const context = yield* withSourceHome();
    const fileSystem = yield* FileSystem.FileSystem;
    const root = safari.userDataDirectory(context)!;
    const library = context.path.dirname(root);
    yield* fileSystem.makeDirectory(root, { recursive: true });
    yield* fileSystem.writeFileString(context.path.join(root, "Cookies.binarycookies"), "default");
    const store = (uuid: string) =>
      context.path.join(library, "WebKit", "WebsiteDataStore", uuid.toLowerCase(), "Cookies");
    for (const uuid of [workUuid, otherUuid]) {
      yield* fileSystem.makeDirectory(store(uuid), { recursive: true });
      yield* fileSystem.writeFileString(
        context.path.join(store(uuid), "Cookies.binarycookies"),
        uuid,
      );
    }
    yield* fileSystem.makeDirectory(context.path.join(library, "Safari"), { recursive: true });
    const metadata = context.path.join(library, "Safari", "SafariTabs.db");
    return { context, root, store, metadata };
  });

  it.effect("discovers named profiles and resolves only the selected profile's cookies", () =>
    run(
      Effect.gen(function* () {
        const { context, root, store, metadata } = yield* fixture();
        yield* Effect.sync(() => {
          const database = new NodeSqlite.DatabaseSync(metadata);
          try {
            database.exec(`CREATE TABLE bookmarks (
            title TEXT, external_uuid TEXT, parent INTEGER DEFAULT 0,
            type INTEGER DEFAULT 1, subtype INTEGER DEFAULT 2,
            deleted INTEGER DEFAULT 0, order_index INTEGER DEFAULT 0
          )`);
            const insert = database.prepare(
              "INSERT INTO bookmarks (title, external_uuid, deleted) VALUES (?, ?, ?)",
            );
            insert.run("", "DefaultProfile", 0);
            insert.run("Ping", workUuid, 0);
            insert.run("Deleted", otherUuid, 1);
            insert.run("Unsafe", "../../outside", 0);
            database.exec(
              "INSERT INTO bookmarks (title, external_uuid, subtype) VALUES ('Tab group', 'group', 1)",
            );
          } finally {
            database.close();
          }
        });
        const profiles = yield* listSourceProfiles(safari, context);
        assert.deepEqual(profiles, [
          { directory: ".", name: "Personal" },
          { directory: store(workUuid), name: "Ping" },
        ]);
        assert.strictEqual(
          yield* resolveCookieDatabase(safari, context, "."),
          context.path.join(root, "Cookies.binarycookies"),
        );
        const selected = yield* resolveCookieDatabase(safari, context, profiles[1]!.directory);
        assert.strictEqual(selected, context.path.join(store(workUuid), "Cookies.binarycookies"));
        const fileSystem = yield* FileSystem.FileSystem;
        assert.strictEqual(yield* fileSystem.readFileString(selected!), workUuid);
        yield* fileSystem.remove(selected!);
        assert.isUndefined(yield* resolveCookieDatabase(safari, context, profiles[1]!.directory));
        assert.deepEqual(yield* listSourceProfiles(safari, context), profiles);
      }),
    ),
  );

  it.effect.each(["missing", "corrupt"] as const)(
    "recovers separate cookie stores when metadata is %s",
    (metadataState) =>
      run(
        Effect.gen(function* () {
          const { context, store, metadata } = yield* fixture();
          const fileSystem = yield* FileSystem.FileSystem;
          if (metadataState === "corrupt") yield* fileSystem.writeFileString(metadata, "invalid");
          yield* fileSystem.remove(context.path.join(store(otherUuid), "Cookies.binarycookies"));
          assert.deepEqual(yield* listSourceProfiles(safari, context), [
            { directory: ".", name: "Safari" },
            { directory: store(workUuid), name: workUuid.toLowerCase() },
          ]);
          assert.isTrue(yield* isSourceInstalled(safari, context));
        }),
      ),
  );
});