Release v0.1.6 2026-07-12

src/frontend/accountRepository.ts

@@ -1,132 +1,40 @@
-import type { StorageAdapter } from "./saveRepository";
-
-const ACCOUNTS_KEY = "i-want-to-heal:accounts:v1";
-const PASSWORD_ITERATIONS = 120_000;
-
-interface AccountRecord {
-  username: string;
-  salt: string;
-  passwordHash: string;
-}
-
-type AccountMap = Record<string, AccountRecord>;
-type PasswordHasher = (password: string, salt: string) => Promise<string>;
+import { OnlineApiError, OnlineRepository, onlineRepository } from "./onlineRepository";
 
 export type AccountResult =
   | { ok: true; username: string }
-  | { ok: false; reason: "missing-credentials" | "account-exists" | "account-not-found" | "invalid-password" | "storage-unavailable" };
+  | { ok: false; reason: "missing-credentials" | "account-exists" | "invalid-password" | "server-unavailable" | "invalid-request"; message?: string };
 
-const fallbackMemory = new Map<string, string>();
-const fallbackStorage: StorageAdapter = {
-  getItem: (key) => fallbackMemory.get(key) ?? null,
-  setItem: (key, value) => { fallbackMemory.set(key, value); },
-};
-
-function browserStorage(): StorageAdapter {
-  try {
-    if (typeof localStorage !== "undefined") return localStorage;
-  } catch {
-    // Android WebView can deny storage before its host is ready.
-  }
-  return fallbackStorage;
+function failure(error: unknown): Extract<AccountResult, { ok: false }> {
+  if (!(error instanceof OnlineApiError)) return { ok: false, reason: "server-unavailable" };
+  if (error.status === 0 || error.status >= 500) return { ok: false, reason: "server-unavailable", message: error.message };
+  if (error.status === 409) return { ok: false, reason: "account-exists", message: error.message };
+  if (error.status === 401) return { ok: false, reason: "invalid-password", message: error.message };
+  return { ok: false, reason: "invalid-request", message: error.message };
 }
 
-function encodeBytes(bytes: Uint8Array) {
-  let binary = "";
-  for (const byte of bytes) binary += String.fromCharCode(byte);
-  return btoa(binary);
-}
-
-function decodeBytes(value: string) {
-  const binary = atob(value);
-  return Uint8Array.from(binary, (character) => character.charCodeAt(0));
-}
-
-async function hashPassword(password: string, salt: string) {
-  const key = await crypto.subtle.importKey(
-    "raw",
-    new TextEncoder().encode(password),
-    "PBKDF2",
-    false,
-    ["deriveBits"],
-  );
-  const bits = await crypto.subtle.deriveBits({
-    name: "PBKDF2",
-    hash: "SHA-256",
-    salt: decodeBytes(salt),
-    iterations: PASSWORD_ITERATIONS,
-  }, key, 256);
-  return encodeBytes(new Uint8Array(bits));
-}
-
-function randomSalt() {
-  const salt = new Uint8Array(16);
-  crypto.getRandomValues(salt);
-  return encodeBytes(salt);
-}
-
-function canonicalUsername(username: string) {
-  return username.trim().toLocaleLowerCase();
-}
-
-function parseAccounts(raw: string | null): AccountMap {
-  if (!raw) return {};
-  try {
-    const parsed = JSON.parse(raw) as AccountMap;
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-
-/**
- * Local prototype account registry. Passwords are salted and derived before
- * persistence; replace this adapter with the server authentication API when
- * remote sync leaves local prototype storage.
- */
 export class AccountRepository {
-  constructor(
-    private readonly storage: StorageAdapter = browserStorage(),
-    private readonly hasher: PasswordHasher = hashPassword,
-    private readonly createSalt: () => string = randomSalt,
-  ) {}
-
-  async create(usernameInput: string, password: string): Promise<AccountResult> {
-    const username = usernameInput.trim();
-    const canonical = canonicalUsername(username);
-    if (!canonical || !password) return { ok: false, reason: "missing-credentials" };
-
-    const accounts = this.read();
-    if (accounts[canonical]) return { ok: false, reason: "account-exists" };
+  constructor(private readonly online: OnlineRepository = onlineRepository) {}
 
+  async create(username: string, password: string): Promise<AccountResult> {
+    if (!username.trim() || !password) return { ok: false, reason: "missing-credentials" };
     try {
-      const salt = this.createSalt();
-      accounts[canonical] = { username, salt, passwordHash: await this.hasher(password, salt) };
-      this.storage.setItem(ACCOUNTS_KEY, JSON.stringify(accounts));
-      return { ok: true, username };
-    } catch {
-      return { ok: false, reason: "storage-unavailable" };
+      const account = await this.online.register(username, password);
+      return { ok: true, username: account.username };
+    } catch (error) {
+      return failure(error);
     }
   }
 
-  async authenticate(usernameInput: string, password: string): Promise<AccountResult> {
-    const canonical = canonicalUsername(usernameInput);
-    if (!canonical || !password) return { ok: false, reason: "missing-credentials" };
-
-    const account = this.read()[canonical];
-    if (!account) return { ok: false, reason: "account-not-found" };
-
+  async authenticate(username: string, password: string): Promise<AccountResult> {
+    if (!username.trim() || !password) return { ok: false, reason: "missing-credentials" };
     try {
-      const passwordHash = await this.hasher(password, account.salt);
-      return passwordHash === account.passwordHash
-        ? { ok: true, username: account.username }
-        : { ok: false, reason: "invalid-password" };
-    } catch {
-      return { ok: false, reason: "storage-unavailable" };
+      const account = await this.online.login(username, password);
+      return { ok: true, username: account.username };
+    } catch (error) {
+      return failure(error);
     }
   }
 
-  private read() {
-    return parseAccounts(this.storage.getItem(ACCOUNTS_KEY));
-  }
+  session() { return this.online.session(); }
+  logout() { return this.online.logout(); }
 }