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

// @effect-diagnostics nodeBuiltinImport:off -- The Clerk bridge must lock the token file down before startup can yield to Electron's ready event.
import * as NodeFS from "node:fs";
import * as NodePath from "node:path";

// electron-store chmods every write to 0666; the private directory protects tokens during writes.
const CLERK_TOKEN_DIRECTORY_MODE = 0o700;
const CLERK_TOKEN_FILE_MODE = 0o600;
const CLERK_TOKEN_DIRECTORY_NAME = "clerk";
const CLERK_TOKEN_FILE_NAME = "clerk-tokens.json";

type Awaitable<T> = T | Promise<T>;

export interface ClerkTokenStorage {
  readonly getItem: (key: string) => Awaitable<string | null>;
  readonly setItem: (key: string, value: string) => Awaitable<void>;
  readonly removeItem: (key: string) => Awaitable<void>;
}

function isErrno(error: unknown, code: string): boolean {
  return typeof error === "object" && error !== null && "code" in error && error.code === code;
}

function lstatIfExists(path: string): NodeFS.Stats | undefined {
  try {
    return NodeFS.lstatSync(path);
  } catch (error) {
    if (isErrno(error, "ENOENT")) return undefined;
    throw error;
  }
}

function assertRegularFile(path: string, stat: NodeFS.Stats): void {
  if (stat.isSymbolicLink() || !stat.isFile()) {
    throw new Error(`Clerk token file "${path}" must be a regular file.`);
  }
}

function restrictClerkTokenFile(path: string): void {
  const stat = lstatIfExists(path);
  if (stat === undefined) return;
  assertRegularFile(path, stat);
  if ((stat.mode & 0o777) === CLERK_TOKEN_FILE_MODE) return;
  NodeFS.chmodSync(path, CLERK_TOKEN_FILE_MODE);
}

function migrateLegacyClerkTokenFile(stateDir: string, directory: string): void {
  const legacyPath = NodePath.join(stateDir, CLERK_TOKEN_FILE_NAME);
  const tokenPath = NodePath.join(directory, CLERK_TOKEN_FILE_NAME);
  const legacy = lstatIfExists(legacyPath);
  if (legacy !== undefined) {
    assertRegularFile(legacyPath, legacy);
    NodeFS.chmodSync(legacyPath, CLERK_TOKEN_FILE_MODE);
  }

  const destination = lstatIfExists(tokenPath);
  if (destination === undefined) {
    if (legacy === undefined) return;
    try {
      NodeFS.copyFileSync(legacyPath, tokenPath, NodeFS.constants.COPYFILE_EXCL);
      NodeFS.chmodSync(tokenPath, CLERK_TOKEN_FILE_MODE);
      NodeFS.unlinkSync(legacyPath);
    } catch (error) {
      if (!isErrno(error, "ENOENT")) throw error;
    }
    return;
  }

  assertRegularFile(tokenPath, destination);
  NodeFS.chmodSync(tokenPath, CLERK_TOKEN_FILE_MODE);
  if (legacy === undefined) return;
  try {
    NodeFS.unlinkSync(legacyPath);
  } catch (error) {
    if (!isErrno(error, "ENOENT")) throw error;
  }
}

function restrictAfter<T>(run: () => Awaitable<T>, tighten: () => void): Awaitable<T> {
  let result: Awaitable<T>;
  try {
    result = run();
  } catch (error) {
    tighten();
    throw error;
  }
  if (result instanceof Promise) return result.finally(tighten);
  tighten();
  return result;
}

/** Opens Clerk token storage in a private directory and keeps the file at `0600`. */
export function openClerkTokenStorage(
  stateDir: string,
  createStorage: (directory: string) => ClerkTokenStorage,
  userDataPath = ".",
): ClerkTokenStorage {
  const absoluteStateDir = NodePath.resolve(stateDir);
  const directory = NodePath.join(absoluteStateDir, CLERK_TOKEN_DIRECTORY_NAME);
  NodeFS.mkdirSync(directory, { recursive: true, mode: CLERK_TOKEN_DIRECTORY_MODE });
  const stat = NodeFS.lstatSync(directory);
  if (stat.isSymbolicLink() || !stat.isDirectory()) {
    throw new Error(`Clerk token directory "${directory}" must be a real directory.`);
  }
  NodeFS.chmodSync(directory, CLERK_TOKEN_DIRECTORY_MODE);
  // electron-store rebases relative paths under Electron userData, not the working directory.
  migrateLegacyClerkTokenFile(NodePath.resolve(userDataPath, stateDir), directory);
  const tokenPath = NodePath.join(directory, CLERK_TOKEN_FILE_NAME);
  restrictClerkTokenFile(tokenPath);

  const storage = createStorage(directory);
  const tighten = () => restrictClerkTokenFile(tokenPath);
  return {
    getItem: (key) => restrictAfter(() => storage.getItem(key), tighten),
    setItem: (key, value) => restrictAfter(() => storage.setItem(key, value), tighten),
    removeItem: (key) => restrictAfter(() => storage.removeItem(key), tighten),
  };
}