@remit/web-client 0.0.1

package/src/lib/account-order.test.ts

@@ -0,0 +1,84 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import type { RemitImapAccountResponse } from "@remit/api-http-client/types.gen.ts";
+import { compareAccounts, sortAccountsByCreatedAt } from "./account-order.js";
+
+const account = (
+	overrides: Partial<RemitImapAccountResponse> &
+		Pick<RemitImapAccountResponse, "accountId" | "createdAt">,
+): RemitImapAccountResponse =>
+	({
+		accountConfigId: "cfg-1",
+		username: "user",
+		email: "user@example.com",
+		imapHost: "imap.example.com",
+		imapPort: 993,
+		imapTls: true,
+		imapStartTls: false,
+		smtpHost: "smtp.example.com",
+		smtpPort: 587,
+		smtpTls: false,
+		smtpStartTls: true,
+		smtpUsername: "user",
+		isActive: true,
+		updatedAt: overrides.createdAt,
+		...overrides,
+	}) as RemitImapAccountResponse;
+
+describe("compareAccounts", () => {
+	test("oldest createdAt sorts first", () => {
+		const a = account({ accountId: "z", createdAt: 1000 });
+		const b = account({ accountId: "a", createdAt: 2000 });
+		assert.ok(compareAccounts(a, b) < 0);
+		assert.ok(compareAccounts(b, a) > 0);
+	});
+
+	test("ties on createdAt are broken by accountId ascending", () => {
+		const a = account({ accountId: "a", createdAt: 1000 });
+		const b = account({ accountId: "b", createdAt: 1000 });
+		assert.ok(compareAccounts(a, b) < 0);
+		assert.ok(compareAccounts(b, a) > 0);
+	});
+
+	test("identical accounts compare equal", () => {
+		const a = account({ accountId: "x", createdAt: 1000 });
+		const b = account({ accountId: "x", createdAt: 1000 });
+		assert.strictEqual(compareAccounts(a, b), 0);
+	});
+});
+
+describe("sortAccountsByCreatedAt", () => {
+	test("returns a new array sorted oldest-first", () => {
+		const input = [
+			account({ accountId: "c", createdAt: 3000 }),
+			account({ accountId: "a", createdAt: 1000 }),
+			account({ accountId: "b", createdAt: 2000 }),
+		];
+		const sorted = sortAccountsByCreatedAt(input);
+		assert.deepStrictEqual(
+			sorted.map((a) => a.accountId),
+			["a", "b", "c"],
+		);
+		assert.deepStrictEqual(
+			input.map((a) => a.accountId),
+			["c", "a", "b"],
+		);
+	});
+
+	test("ties on createdAt sort by accountId", () => {
+		const input = [
+			account({ accountId: "z", createdAt: 1000 }),
+			account({ accountId: "a", createdAt: 1000 }),
+			account({ accountId: "m", createdAt: 1000 }),
+		];
+		const sorted = sortAccountsByCreatedAt(input);
+		assert.deepStrictEqual(
+			sorted.map((a) => a.accountId),
+			["a", "m", "z"],
+		);
+	});
+
+	test("empty input returns empty array", () => {
+		assert.deepStrictEqual(sortAccountsByCreatedAt([]), []);
+	});
+});

package/src/lib/account-order.ts

@@ -0,0 +1,13 @@
+import type { RemitImapAccountResponse } from "@remit/api-http-client/types.gen.ts";
+
+export const compareAccounts = (
+	a: RemitImapAccountResponse,
+	b: RemitImapAccountResponse,
+): number => {
+	if (a.createdAt !== b.createdAt) return a.createdAt - b.createdAt;
+	return a.accountId.localeCompare(b.accountId);
+};
+
+export const sortAccountsByCreatedAt = <T extends RemitImapAccountResponse>(
+	accounts: readonly T[],
+): T[] => [...accounts].sort(compareAccounts);

package/src/lib/adjacent-message.test.ts

@@ -0,0 +1,43 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { adjacentMessageId } from "./adjacent-message.js";
+
+describe("adjacentMessageId", () => {
+	const ids = ["a", "b", "c"];
+
+	test("next returns the following id", () => {
+		assert.strictEqual(adjacentMessageId(ids, "a", "next"), "b");
+		assert.strictEqual(adjacentMessageId(ids, "b", "next"), "c");
+	});
+
+	test("previous returns the preceding id", () => {
+		assert.strictEqual(adjacentMessageId(ids, "c", "previous"), "b");
+		assert.strictEqual(adjacentMessageId(ids, "b", "previous"), "a");
+	});
+
+	test("returns null at the end of the list (no wrap)", () => {
+		assert.strictEqual(adjacentMessageId(ids, "c", "next"), null);
+	});
+
+	test("returns null at the start of the list (no wrap)", () => {
+		assert.strictEqual(adjacentMessageId(ids, "a", "previous"), null);
+	});
+
+	test("returns null when current id is not in the list", () => {
+		assert.strictEqual(adjacentMessageId(ids, "z", "next"), null);
+		assert.strictEqual(adjacentMessageId(ids, "z", "previous"), null);
+	});
+
+	test("returns null when there is no current id", () => {
+		assert.strictEqual(adjacentMessageId(ids, undefined, "next"), null);
+	});
+
+	test("returns null for a single-item list at both ends", () => {
+		assert.strictEqual(adjacentMessageId(["only"], "only", "next"), null);
+		assert.strictEqual(adjacentMessageId(["only"], "only", "previous"), null);
+	});
+
+	test("returns null for an empty list", () => {
+		assert.strictEqual(adjacentMessageId([], "a", "next"), null);
+	});
+});

package/src/lib/adjacent-message.ts

@@ -0,0 +1,20 @@
+/**
+ * Resolves the message id adjacent to `currentId` in `orderedIds`.
+ *
+ * The list is in display order (newest first). "next" walks down the list
+ * (older), "previous" walks up (newer) — matching the j/k keyboard navigation
+ * and the visual top-to-bottom order. Returns `null` at the ends of the list
+ * (no wrap) and when the current id is not present.
+ */
+export const adjacentMessageId = (
+	orderedIds: string[],
+	currentId: string | undefined,
+	direction: "next" | "previous",
+): string | null => {
+	if (!currentId) return null;
+	const index = orderedIds.indexOf(currentId);
+	if (index === -1) return null;
+	const target = direction === "next" ? index + 1 : index - 1;
+	if (target < 0 || target >= orderedIds.length) return null;
+	return orderedIds[target];
+};

package/src/lib/api.ts

@@ -0,0 +1,82 @@
+export class ApiError extends Error {
+	constructor(
+		message: string,
+		public status: number,
+		public body?: unknown,
+	) {
+		super(message);
+		this.name = "ApiError";
+	}
+}
+
+interface RequestOptions extends Omit<RequestInit, "body"> {
+	params?: Record<string, string | number | boolean | undefined>;
+	body?: unknown;
+}
+
+const buildUrl = (
+	path: string,
+	params?: Record<string, string | number | boolean | undefined>,
+): string => {
+	const url = new URL(path, window.location.origin);
+	if (params) {
+		Object.entries(params).forEach(([key, value]) => {
+			if (value !== undefined) {
+				url.searchParams.set(key, String(value));
+			}
+		});
+	}
+	return url.toString();
+};
+
+const request = async <T>(
+	method: string,
+	path: string,
+	options: RequestOptions = {},
+): Promise<T> => {
+	const { params, body, headers, ...rest } = options;
+
+	const url = buildUrl(path, params);
+
+	const response = await fetch(url, {
+		method,
+		headers: {
+			"Content-Type": "application/json",
+			...headers,
+		},
+		body: body ? JSON.stringify(body) : undefined,
+		...rest,
+	});
+
+	if (!response.ok) {
+		const errorBody = await response.json().catch(() => undefined);
+		throw new ApiError(
+			errorBody?.message || `Request failed with status ${response.status}`,
+			response.status,
+			errorBody,
+		);
+	}
+
+	if (response.status === 204) {
+		return undefined as T;
+	}
+
+	return response.json();
+};
+
+export const api = {
+	get: <T>(path: string, options?: RequestOptions) =>
+		request<T>("GET", path, options),
+
+	post: <T>(path: string, body?: unknown, options?: RequestOptions) =>
+		request<T>("POST", path, { ...options, body }),
+
+	put: <T>(path: string, body?: unknown, options?: RequestOptions) =>
+		request<T>("PUT", path, { ...options, body }),
+
+	patch: <T>(path: string, body?: unknown, options?: RequestOptions) =>
+		request<T>("PATCH", path, { ...options, body }),
+
+	delete: <T>(path: string, options?: RequestOptions) =>
+		request<T>("DELETE", path, options),
+};

package/src/lib/app-info.ts

@@ -0,0 +1,15 @@
+/**
+ * Build-time constants injected by vite.config.ts via `define`.
+ * __APP_SHA__ is the full git SHA (or "dev" in local builds without git).
+ * __APP_BUILD_TIME__ is an ISO timestamp.
+ */
+
+export const APP_SHA: string = __APP_SHA__;
+export const APP_BUILD_TIME: string = __APP_BUILD_TIME__;
+
+/** First 7 characters of the SHA, matching git's default short form. */
+export const APP_SHORT_SHA: string = APP_SHA.slice(0, 7);
+
+export const GITHUB_COMMIT_URL = `https://github.com/remit-mail/remit/commit/${APP_SHA}`;
+export const GITHUB_NEW_ISSUE_URL =
+	"https://github.com/remit-mail/remit/issues/new";

package/src/lib/auto-moved.test.ts

@@ -0,0 +1,140 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import type { RemitImapAutoMovedInfo } from "@remit/api-http-client/types.gen.ts";
+import { PlacementAction } from "@remit/domain-enums";
+import {
+	type AutoMovedRoleMailboxes,
+	autoMovedLabel,
+	isAutoMoveInEffect,
+	resolveUndoTargetMailboxId,
+} from "./auto-moved.js";
+
+const ROLE_MAILBOXES: AutoMovedRoleMailboxes = {
+	inboxMailboxId: "mb-inbox",
+	junkMailboxId: "mb-junk",
+};
+
+describe("autoMovedLabel", () => {
+	test("reads 'Moved from Junk by Remit'", () => {
+		assert.equal(autoMovedLabel("junk"), "Moved from Junk by Remit");
+	});
+
+	test("reads 'Moved from Inbox by Remit'", () => {
+		assert.equal(autoMovedLabel("inbox"), "Moved from Inbox by Remit");
+	});
+
+	test("falls back to plain language for an unrecognized placement", () => {
+		assert.equal(autoMovedLabel("other"), "Moved from another folder by Remit");
+	});
+
+	test("never leaks verdict jargon", () => {
+		for (const placement of ["inbox", "junk", "other"]) {
+			assert.doesNotMatch(
+				autoMovedLabel(placement),
+				/confiden|dry.?run|verdict/i,
+			);
+		}
+	});
+});
+
+describe("isAutoMoveInEffect", () => {
+	test("false when autoMoved is absent", () => {
+		assert.equal(
+			isAutoMoveInEffect(undefined, "mb-inbox", ROLE_MAILBOXES),
+			false,
+		);
+	});
+
+	test("false when currentMailboxId is absent", () => {
+		const autoMoved: RemitImapAutoMovedInfo = {
+			action: PlacementAction.MoveToInbox,
+			fromPlacement: "junk",
+		};
+		assert.equal(
+			isAutoMoveInEffect(autoMoved, undefined, ROLE_MAILBOXES),
+			false,
+		);
+	});
+
+	test("true when a MoveToInbox message currently sits in the Inbox mailbox", () => {
+		const autoMoved: RemitImapAutoMovedInfo = {
+			action: PlacementAction.MoveToInbox,
+			fromPlacement: "junk",
+		};
+		assert.equal(
+			isAutoMoveInEffect(autoMoved, "mb-inbox", ROLE_MAILBOXES),
+			true,
+		);
+	});
+
+	test("true when a MoveToJunk message currently sits in the Junk mailbox", () => {
+		const autoMoved: RemitImapAutoMovedInfo = {
+			action: PlacementAction.MoveToJunk,
+			fromPlacement: "inbox",
+		};
+		assert.equal(
+			isAutoMoveInEffect(autoMoved, "mb-junk", ROLE_MAILBOXES),
+			true,
+		);
+	});
+
+	test("false once the message has moved elsewhere (self-hide on reconcile)", () => {
+		const autoMoved: RemitImapAutoMovedInfo = {
+			action: PlacementAction.MoveToInbox,
+			fromPlacement: "junk",
+		};
+		assert.equal(
+			isAutoMoveInEffect(autoMoved, "mb-archive", ROLE_MAILBOXES),
+			false,
+		);
+		// Undone back to Junk — no longer in the implied destination.
+		assert.equal(
+			isAutoMoveInEffect(autoMoved, "mb-junk", ROLE_MAILBOXES),
+			false,
+		);
+	});
+
+	test("false when the implied destination mailbox hasn't resolved yet", () => {
+		const autoMoved: RemitImapAutoMovedInfo = {
+			action: PlacementAction.MoveToInbox,
+			fromPlacement: "junk",
+		};
+		assert.equal(
+			isAutoMoveInEffect(autoMoved, "mb-inbox", {
+				inboxMailboxId: undefined,
+				junkMailboxId: "mb-junk",
+			}),
+			false,
+		);
+	});
+});
+
+describe("resolveUndoTargetMailboxId", () => {
+	test("resolves the Junk mailbox for fromPlacement='junk'", () => {
+		assert.equal(resolveUndoTargetMailboxId("junk", ROLE_MAILBOXES), "mb-junk");
+	});
+
+	test("resolves the Inbox mailbox for fromPlacement='inbox'", () => {
+		assert.equal(
+			resolveUndoTargetMailboxId("inbox", ROLE_MAILBOXES),
+			"mb-inbox",
+		);
+	});
+
+	test("undefined for an unresolvable placement", () => {
+		assert.equal(
+			resolveUndoTargetMailboxId("other", ROLE_MAILBOXES),
+			undefined,
+		);
+	});
+
+	test("undefined when the role mailbox hasn't resolved yet", () => {
+		assert.equal(
+			resolveUndoTargetMailboxId("junk", {
+				inboxMailboxId: "mb-inbox",
+				junkMailboxId: undefined,
+			}),
+			undefined,
+		);
+	});
+});

package/src/lib/auto-moved.ts

@@ -0,0 +1,68 @@
+import type { RemitImapAutoMovedInfo } from "@remit/api-http-client/types.gen.ts";
+import { PlacementAction } from "@remit/domain-enums";
+
+/** The two folder roles the account's mailboxes can resolve for this feature. */
+export interface AutoMovedRoleMailboxes {
+	inboxMailboxId: string | undefined;
+	junkMailboxId: string | undefined;
+}
+
+const FROM_PLACEMENT_LABEL: Record<string, string> = {
+	inbox: "Inbox",
+	junk: "Junk",
+};
+
+/**
+ * Plain-language badge text, e.g. "Moved from Junk by Remit". No jargon
+ * (verdict/confidence/dryRun never surface) — mirrors the no-jargon precedent
+ * in `rescue-candidates.ts`.
+ */
+export const autoMovedLabel = (fromPlacement: string): string =>
+	`Moved from ${FROM_PLACEMENT_LABEL[fromPlacement] ?? "another folder"} by Remit`;
+
+/**
+ * The mailbox the verdict's `action` implies as the destination — where the
+ * message should currently sit for the move to still be "in effect".
+ */
+const impliedDestinationMailboxId = (
+	action: string,
+	mailboxes: AutoMovedRoleMailboxes,
+): string | undefined => {
+	if (action === PlacementAction.MoveToInbox) return mailboxes.inboxMailboxId;
+	if (action === PlacementAction.MoveToJunk) return mailboxes.junkMailboxId;
+	return undefined;
+};
+
+/**
+ * True only while the auto-move is still in effect: the message currently
+ * sits in the mailbox the verdict's `action` implied. Once the message moves
+ * elsewhere (an undo, or any other move), this returns false — the badge has
+ * no local "dismissed" flag; it re-derives from current placement every
+ * render, per the data-flow rule that a projection never forks from its
+ * source (doc/rules/data-flow.md).
+ */
+export const isAutoMoveInEffect = (
+	autoMoved: RemitImapAutoMovedInfo | undefined,
+	currentMailboxId: string | undefined,
+	mailboxes: AutoMovedRoleMailboxes,
+): boolean => {
+	if (!autoMoved || !currentMailboxId) return false;
+	const destination = impliedDestinationMailboxId(autoMoved.action, mailboxes);
+	return destination !== undefined && destination === currentMailboxId;
+};
+
+/**
+ * Resolve the undo destination: the mailbox filling the role the message was
+ * moved from. `fromPlacement` is always `inbox` or `junk` for an actionable
+ * verdict (the Tier 0 classifier only fires move-to-inbox from junk and
+ * move-to-junk from inbox — see `classifyPlacement.ts`); `undefined` when the
+ * account has no mailbox appointed to that role.
+ */
+export const resolveUndoTargetMailboxId = (
+	fromPlacement: string,
+	mailboxes: AutoMovedRoleMailboxes,
+): string | undefined => {
+	if (fromPlacement === "inbox") return mailboxes.inboxMailboxId;
+	if (fromPlacement === "junk") return mailboxes.junkMailboxId;
+	return undefined;
+};

package/src/lib/autodiscovery.test.ts

@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	discoverSettings,
+	getAppPasswordUrl,
+	getDiscoveryStatusMessage,
+} from "./autodiscovery.js";
+
+// Provider table unit tests for top 5 providers (no network calls)
+describe("autodiscovery provider table", () => {
+	it("resolves Gmail", async () => {
+		const result = await discoverSettings("user@gmail.com");
+		assert.ok(result, "should find Gmail");
+		assert.equal(result.source, "provider-table");
+		assert.equal(result.imap.host, "imap.gmail.com");
+		assert.equal(result.imap.port, 993);
+		assert.equal(result.imap.security, "tls");
+		assert.equal(result.smtp.host, "smtp.gmail.com");
+		assert.equal(result.smtp.port, 587);
+		assert.equal(result.smtp.security, "starttls");
+	});
+
+	it("resolves iCloud", async () => {
+		const result = await discoverSettings("user@icloud.com");
+		assert.ok(result, "should find iCloud");
+		assert.equal(result.source, "provider-table");
+		assert.equal(result.imap.host, "imap.mail.me.com");
+		assert.equal(result.imap.port, 993);
+		assert.equal(result.smtp.security, "starttls");
+	});
+
+	it("resolves Fastmail", async () => {
+		const result = await discoverSettings("user@fastmail.com");
+		assert.ok(result, "should find Fastmail");
+		assert.equal(result.source, "provider-table");
+		assert.equal(result.imap.host, "imap.fastmail.com");
+		assert.equal(result.smtp.host, "smtp.fastmail.com");
+		assert.equal(result.smtp.port, 465);
+		assert.equal(result.smtp.security, "tls");
+	});
+
+	it("resolves Outlook", async () => {
+		const result = await discoverSettings("user@outlook.com");
+		assert.ok(result, "should find Outlook");
+		assert.equal(result.source, "provider-table");
+		assert.equal(result.imap.host, "outlook.office365.com");
+		assert.equal(result.smtp.host, "smtp.office365.com");
+	});
+
+	it("resolves Yahoo", async () => {
+		const result = await discoverSettings("user@yahoo.com");
+		assert.ok(result, "should find Yahoo");
+		assert.equal(result.source, "provider-table");
+		assert.equal(result.imap.host, "imap.mail.yahoo.com");
+		assert.equal(result.smtp.security, "tls");
+	});
+
+	it("returns heuristic for unknown domain", async () => {
+		// Use a clearly fake domain — network calls will fail/timeout
+		// In the test environment there's no network, so it falls to heuristic
+		const result = await discoverSettings(
+			"user@no-such-domain-xyz123.test",
+			100,
+		);
+		assert.ok(result, "should return heuristic result");
+		assert.equal(result.source, "heuristic");
+		assert.equal(result.imap.host, "imap.no-such-domain-xyz123.test");
+		assert.equal(result.smtp.host, "smtp.no-such-domain-xyz123.test");
+	});
+
+	it("returns null for invalid email", async () => {
+		const result = await discoverSettings("not-an-email");
+		assert.equal(result, null);
+	});
+});
+
+describe("getDiscoveryStatusMessage", () => {
+	it("includes domain in message", () => {
+		const msg = getDiscoveryStatusMessage("user@fastmail.com");
+		assert.ok(msg.includes("fastmail.com"), "should include domain");
+	});
+});
+
+describe("getAppPasswordUrl", () => {
+	it("returns Gmail app password URL", () => {
+		const url = getAppPasswordUrl("user@gmail.com");
+		assert.ok(url?.includes("google.com"), "should include google.com");
+	});
+
+	it("returns undefined for unknown domain", () => {
+		const url = getAppPasswordUrl("user@unknown-provider.test");
+		assert.equal(url, undefined);
+	});
+});