sailfork / t3code-github / apps/ desktop/ src/ app/ ClerkTokenStore.test.ts

// @effect-diagnostics nodeBuiltinImport:off -- These tests assert real POSIX modes on a temporary directory.
import * as NodeFS from "node:fs";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import { assert, describe, it } from "@effect/vitest";
import { vi } from "vite-plus/test";

vi.mock("node:fs", { spy: true });

import { openClerkTokenStorage, type ClerkTokenStorage } from "./ClerkTokenStore.ts";

// oxlint-disable-next-line t3code/no-global-process-runtime -- Unix mode bits are the assertion; Windows reports them through ACLs.
const describePosix = describe.skipIf(process.platform === "win32");

const modeOf = (path: string): number => NodeFS.statSync(path).mode & 0o777;

function writeLoose(path: string, contents: string): void {
  NodeFS.writeFileSync(path, contents, { mode: 0o666 });
  NodeFS.chmodSync(path, 0o666);
}

async function withStateDir(run: (stateDir: string) => Promise<void> | void): Promise<void> {
  const stateDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-clerk-tokens-"));
  try {
    await run(stateDir);
  } finally {
    NodeFS.rmSync(stateDir, { recursive: true, force: true });
  }
}

const idleStorage = (): ClerkTokenStorage => ({
  getItem: async () => null,
  setItem: async () => undefined,
  removeItem: () => undefined,
});

describePosix("ClerkTokenStore", () => {
  it("keeps clerk tokens at 0600 inside a 0700 directory", async () => {
    await withStateDir(async (stateDir) => {
      NodeFS.chmodSync(stateDir, 0o755);
      const directory = NodePath.join(stateDir, "clerk");
      const legacyPath = NodePath.join(stateDir, "clerk-tokens.json");
      const tokenPath = NodePath.join(directory, "clerk-tokens.json");
      NodeFS.mkdirSync(directory, { mode: 0o755 });
      NodeFS.chmodSync(directory, 0o755);
      writeLoose(legacyPath, '{"__clerk_client_jwt":"enc:existing"}\n');

      const opened: string[] = [];
      const storage = openClerkTokenStorage(stateDir, (cwd) => {
        opened.push(cwd);
        return {
          getItem: async () => {
            writeLoose(tokenPath, "from-get");
            return "from-get";
          },
          setItem: (_key, value) => {
            writeLoose(tokenPath, value);
          },
          removeItem: () => {
            NodeFS.rmSync(tokenPath, { force: true });
          },
        };
      });

      assert.deepEqual(opened, [directory]);
      assert.equal(modeOf(stateDir), 0o755);
      assert.equal(modeOf(directory), 0o700);
      assert.equal(modeOf(tokenPath), 0o600);
      assert.equal(NodeFS.existsSync(legacyPath), false);
      assert.equal(
        NodeFS.readFileSync(tokenPath, "utf8"),
        '{"__clerk_client_jwt":"enc:existing"}\n',
      );

      assert.equal(await storage.getItem("client"), "from-get");
      assert.equal(modeOf(tokenPath), 0o600);
      await storage.setItem("client", "from-set");
      assert.equal(modeOf(tokenPath), 0o600);
      assert.equal(NodeFS.readFileSync(tokenPath, "utf8"), "from-set");
      storage.removeItem("client");
      assert.equal(NodeFS.existsSync(tokenPath), false);

      writeLoose(tokenPath, "kept");
      writeLoose(legacyPath, "stale");
      NodeFS.chmodSync(directory, 0o755);
      openClerkTokenStorage(stateDir, () => idleStorage());
      assert.equal(modeOf(directory), 0o700);
      assert.equal(modeOf(tokenPath), 0o600);
      assert.equal(NodeFS.existsSync(legacyPath), false);
      assert.equal(NodeFS.readFileSync(tokenPath, "utf8"), "kept");
    });
  });

  it("removes the legacy token file when the private copy already exists", async () => {
    await withStateDir((stateDir) => {
      const directory = NodePath.join(stateDir, "clerk");
      const legacyPath = NodePath.join(stateDir, "clerk-tokens.json");
      const tokenPath = NodePath.join(directory, "clerk-tokens.json");
      NodeFS.mkdirSync(directory, { mode: 0o755 });
      writeLoose(legacyPath, "stale-credential");
      writeLoose(tokenPath, "kept-credential");

      openClerkTokenStorage(stateDir, () => idleStorage());

      assert.equal(NodeFS.existsSync(legacyPath), false);
      assert.equal(modeOf(directory), 0o700);
      assert.equal(modeOf(tokenPath), 0o600);
      assert.equal(NodeFS.readFileSync(tokenPath, "utf8"), "kept-credential");
    });
  });

  it("resolves a relative state directory before opening storage", async () => {
    await withStateDir(async (stateDir) => {
      const relativeStateDir = NodePath.relative(process.cwd(), stateDir);
      const opened: string[] = [];
      openClerkTokenStorage(relativeStateDir, (directory) => {
        opened.push(directory);
        return idleStorage();
      });

      const directory = NodePath.join(stateDir, "clerk");
      assert.equal(NodePath.isAbsolute(relativeStateDir), false);
      assert.deepEqual(opened, [directory]);
      assert.equal(modeOf(directory), 0o700);
    });
  });

  it("migrates relative state paths from Electron userData, not the working directory", async () => {
    await withStateDir((stateDir) => {
      const relativeStateDir = NodePath.relative(process.cwd(), stateDir);
      const userData = NodePath.join(
        stateDir,
        "electron",
        ...relativeStateDir.split(NodePath.sep).map(() => "profile"),
      );
      const legacyStateDir = NodePath.join(userData, relativeStateDir);
      const legacyPath = NodePath.join(legacyStateDir, "clerk-tokens.json");
      NodeFS.mkdirSync(legacyStateDir, { recursive: true });
      writeLoose(legacyPath, "existing-session");
      const unrelatedPath = NodePath.join(stateDir, "clerk-tokens.json");
      writeLoose(unrelatedPath, "not-the-electron-session");

      openClerkTokenStorage(relativeStateDir, idleStorage, userData);

      const tokenPath = NodePath.join(stateDir, "clerk", "clerk-tokens.json");
      assert.equal(NodeFS.readFileSync(tokenPath, "utf8"), "existing-session");
      assert.equal(modeOf(tokenPath), 0o600);
      assert.equal(NodeFS.existsSync(legacyPath), false);
      assert.equal(NodeFS.readFileSync(unrelatedPath, "utf8"), "not-the-electron-session");
    });
  });

  it("migrates tokens when the legacy directory is on another filesystem", async () => {
    await withStateDir((stateDir) => {
      const legacyPath = NodePath.join(stateDir, "clerk-tokens.json");
      writeLoose(legacyPath, "existing-session");
      using _rename = vi.spyOn(NodeFS, "renameSync").mockImplementation(() => {
        throw Object.assign(new Error("cross-device link"), { code: "EXDEV" });
      });

      openClerkTokenStorage(stateDir, idleStorage);

      const tokenPath = NodePath.join(stateDir, "clerk", "clerk-tokens.json");
      assert.equal(NodeFS.readFileSync(tokenPath, "utf8"), "existing-session");
      assert.equal(modeOf(tokenPath), 0o600);
      assert.equal(NodeFS.existsSync(legacyPath), false);
    });
  });

  it("does not follow a symlinked clerk directory or token file", async () => {
    await withStateDir(async (stateDir) => {
      const outsideDirectory = NodePath.join(stateDir, "outside-dir");
      NodeFS.mkdirSync(outsideDirectory, { mode: 0o755 });
      NodeFS.chmodSync(outsideDirectory, 0o755);
      NodeFS.symlinkSync(outsideDirectory, NodePath.join(stateDir, "clerk"));

      assert.throws(() => openClerkTokenStorage(stateDir, idleStorage), /must be a real directory/);
      assert.equal(modeOf(outsideDirectory), 0o755);
      NodeFS.unlinkSync(NodePath.join(stateDir, "clerk"));

      const outsideFile = NodePath.join(stateDir, "outside.json");
      NodeFS.writeFileSync(outsideFile, "secret", { mode: 0o644 });
      NodeFS.chmodSync(outsideFile, 0o644);
      NodeFS.symlinkSync(outsideFile, NodePath.join(stateDir, "clerk-tokens.json"));
      assert.throws(() => openClerkTokenStorage(stateDir, idleStorage), /must be a regular file/);
      assert.equal(modeOf(outsideFile), 0o644);
    });
  });
});