birdclaw 0.5.1 → 0.6.0

package/src/lib/actions-transport.ts

@@ -6,15 +6,16 @@ import {
 	unmuteUserViaBird,
 } from "./bird-actions";
 import { type ActionsTransport, resolveActionsTransport } from "./config";
+import { Effect } from "effect";
+import { runEffectPromise, tryPromise } from "./effect-runtime";
 import type {
 	ModerationAction,
 	ModerationActionTransportResult,
 	ModerationTransportKind,
 } from "./types";
-import { blockUserViaXWeb, unblockUserViaXWeb } from "./x-web";
 import {
 	blockUserViaXurl,
-	lookupAuthenticatedUser,
+	lookupAuthenticatedUserFresh,
 	muteUserViaXurl,
 	unblockUserViaXurl,
 	unmuteUserViaXurl,
@@ -27,29 +28,96 @@ interface RunActionParams {
 	query: string;
 	targetUserId?: string;
 	transport?: string;
+	expectedAccount?: ExpectedActionAccount;
+}
+
+export interface ExpectedActionAccount {
+	id: string;
+	handle: string;
+	externalUserId?: string | null;
+}
+
+function toError(error: unknown) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+
+function trySync<T>(try_: () => T) {
+	return Effect.try({
+		try: try_,
+		catch: toError,
+	});
 }
 
 function normalizeFailure(transport: ModerationTransportKind, output: string) {
 	return `${transport}: ${output}`;
 }
 
-async function runBirdAction(
+function liveWritesDisabled() {
+	return process.env.BIRDCLAW_DISABLE_LIVE_WRITES === "1";
+}
+
+function normalizeHandle(value: string | null | undefined) {
+	return value?.replace(/^@/, "").toLowerCase() ?? "";
+}
+
+function verifyExpectedAccountEffect(
+	expectedAccount: ExpectedActionAccount | undefined,
+) {
+	return Effect.gen(function* () {
+		if (!expectedAccount) return null;
+		if (liveWritesDisabled()) return null;
+
+		const sourceUser = yield* tryPromise(() => lookupAuthenticatedUserFresh());
+		const sourceUserId =
+			sourceUser && typeof sourceUser.id === "string" ? sourceUser.id : "";
+		const sourceUsername =
+			sourceUser && typeof sourceUser.username === "string"
+				? normalizeHandle(sourceUser.username)
+				: "";
+		const expectedExternalUserId = expectedAccount.externalUserId?.trim() ?? "";
+		const expectedHandle = normalizeHandle(expectedAccount.handle);
+
+		if (expectedExternalUserId) {
+			if (sourceUserId === expectedExternalUserId) return sourceUserId;
+			return yield* Effect.fail(
+				new Error(
+					`xurl is authenticated as user ${sourceUserId || "unknown"}, not account ${expectedAccount.id}`,
+				),
+			);
+		}
+
+		if (expectedHandle && sourceUsername === expectedHandle)
+			return sourceUserId;
+		return yield* Effect.fail(
+			new Error(
+				sourceUsername
+					? `xurl is authenticated as @${sourceUsername}, not @${expectedHandle}`
+					: "xurl authenticated user unavailable",
+			),
+		);
+	});
+}
+
+function runBirdActionEffect(
 	action: ModerationAction,
 	query: string,
-): Promise<ActionTransportResult> {
-	const result =
-		action === "block"
-			? await blockUserViaBird(query)
-			: action === "unblock"
-				? await unblockUserViaBird(query)
-				: action === "mute"
-					? await muteUserViaBird(query)
-					: await unmuteUserViaBird(query);
-
-	return {
-		...result,
-		transport: "bird",
-	};
+): Effect.Effect<ActionTransportResult, unknown> {
+	return Effect.gen(function* () {
+		const result = yield* tryPromise(() =>
+			action === "block"
+				? blockUserViaBird(query)
+				: action === "unblock"
+					? unblockUserViaBird(query)
+					: action === "mute"
+						? muteUserViaBird(query)
+						: unmuteUserViaBird(query),
+		);
+
+		return {
+			...result,
+			transport: "bird",
+		};
+	});
 }
 
 function getVerifyExpectation(action: ModerationAction) {
@@ -64,145 +132,151 @@ function getVerifyExpectation(action: ModerationAction) {
 			};
 }
 
-async function runXurlAction(
+function runXurlActionEffect(
 	action: ModerationAction,
 	query: string,
 	targetUserId?: string,
-): Promise<ActionTransportResult> {
-	if (!targetUserId) {
-		return {
-			ok: false,
-			output: "missing target user id for xurl transport",
-			transport: "xurl",
-		};
-	}
+	verifiedSourceUserId?: string | null,
+): Effect.Effect<ActionTransportResult, unknown> {
+	return Effect.gen(function* () {
+		if (!targetUserId) {
+			return {
+				ok: false,
+				output: "missing target user id for xurl transport",
+				transport: "xurl",
+			};
+		}
 
-	const sourceUser = await lookupAuthenticatedUser();
-	const sourceUserId =
-		sourceUser && typeof sourceUser.id === "string" ? sourceUser.id : "";
-	if (!sourceUserId) {
-		return {
-			ok: false,
-			output: "xurl authenticated user unavailable",
-			transport: "xurl",
-		};
-	}
-
-	const result =
-		action === "block"
-			? await blockUserViaXurl(sourceUserId, targetUserId)
-			: action === "unblock"
-				? await unblockUserViaXurl(sourceUserId, targetUserId)
-				: action === "mute"
-					? await muteUserViaXurl(sourceUserId, targetUserId)
-					: await unmuteUserViaXurl(sourceUserId, targetUserId);
-
-	if (!result.ok) {
-		return {
-			...result,
-			transport: "xurl",
-		};
-	}
+		let sourceUserId = verifiedSourceUserId ?? "";
+		if (!sourceUserId) {
+			const sourceUser = yield* tryPromise(() =>
+				lookupAuthenticatedUserFresh(),
+			);
+			sourceUserId =
+				sourceUser && typeof sourceUser.id === "string" ? sourceUser.id : "";
+		}
+		if (!sourceUserId) {
+			return {
+				ok: false,
+				output: "xurl authenticated user unavailable",
+				transport: "xurl",
+			};
+		}
 
-	const status = await readBirdStatusViaBird(query);
-	const { field: verifyField, expected: expectedValue } =
-		getVerifyExpectation(action);
-	const actualValue =
-		status && typeof status[verifyField] === "boolean"
-			? Boolean(status[verifyField])
-			: null;
+		const result = yield* tryPromise(() =>
+			action === "block"
+				? blockUserViaXurl(sourceUserId, targetUserId)
+				: action === "unblock"
+					? unblockUserViaXurl(sourceUserId, targetUserId)
+					: action === "mute"
+						? muteUserViaXurl(sourceUserId, targetUserId)
+						: unmuteUserViaXurl(sourceUserId, targetUserId),
+		);
 
-	if (actualValue === null) {
-		return {
-			ok: false,
-			output: `${result.output}\nxurl verify unavailable from bird status`,
-			transport: "xurl",
-		};
-	}
+		if (!result.ok) {
+			return {
+				...result,
+				transport: "xurl",
+			};
+		}
 
-	if (actualValue !== expectedValue) {
-		return {
-			ok: false,
-			output: `${result.output}\nxurl verify mismatch ${verifyField}=${String(actualValue)}`,
-			transport: "xurl",
-		};
-	}
+		const status = yield* tryPromise(() => readBirdStatusViaBird(query));
+		const { field: verifyField, expected: expectedValue } =
+			getVerifyExpectation(action);
+		const actualValue =
+			status && typeof status[verifyField] === "boolean"
+				? Boolean(status[verifyField])
+				: null;
 
-	return {
-		ok: true,
-		output: `${result.output}\nverified ${verifyField}=${String(actualValue)}`,
-		transport: "xurl",
-	};
-}
+		if (actualValue === null) {
+			return {
+				ok: false,
+				output: `${result.output}\nxurl verify unavailable from bird status`,
+				transport: "xurl",
+			};
+		}
 
-async function runXWebAction(
-	action: ModerationAction,
-	targetUserId?: string,
-): Promise<ActionTransportResult> {
-	if (action !== "block" && action !== "unblock") {
-		return {
-			ok: false,
-			output: `x-web does not support ${action}`,
-			transport: "x-web",
-		};
-	}
+		if (actualValue !== expectedValue) {
+			return {
+				ok: false,
+				output: `${result.output}\nxurl verify mismatch ${verifyField}=${String(actualValue)}`,
+				transport: "xurl",
+			};
+		}
 
-	if (!targetUserId) {
 		return {
-			ok: false,
-			output: "missing target user id for x-web transport",
-			transport: "x-web",
+			ok: true,
+			output: `${result.output}\nverified ${verifyField}=${String(actualValue)}`,
+			transport: "xurl",
 		};
-	}
-
-	const result =
-		action === "block"
-			? await blockUserViaXWeb(targetUserId)
-			: await unblockUserViaXWeb(targetUserId);
-
-	return {
-		...result,
-		transport: "x-web",
-	};
+	});
 }
 
-export async function runModerationAction({
+export function runModerationActionEffect({
 	action,
 	query,
 	targetUserId,
 	transport,
-}: RunActionParams): Promise<ActionTransportResult> {
-	const requestedTransport = resolveActionsTransport(transport);
-	if (requestedTransport === "bird") {
-		return runBirdAction(action, query);
-	}
-	if (requestedTransport === "xurl") {
-		return runXurlAction(action, query, targetUserId);
-	}
-
-	const birdResult = await runBirdAction(action, query);
-	if (birdResult.ok) {
-		return birdResult;
-	}
-
-	const xurlResult = await runXurlAction(action, query, targetUserId);
-	if (xurlResult.ok) {
-		return {
-			...xurlResult,
-			output: `${xurlResult.output}\nfalling back after ${normalizeFailure("bird", birdResult.output)}`,
-		};
-	}
+	expectedAccount,
+}: RunActionParams): Effect.Effect<ActionTransportResult, unknown> {
+	return Effect.gen(function* () {
+		const requestedTransport = yield* trySync(() =>
+			resolveActionsTransport(transport),
+		);
+
+		const verifyXurlAccount = () =>
+			verifyExpectedAccountEffect(expectedAccount).pipe(
+				Effect.catchAll((error) =>
+					Effect.succeed({
+						ok: false as const,
+						output: error instanceof Error ? error.message : String(error),
+						transport: "xurl" as const,
+					}),
+				),
+			);
 
-	if (action === "block" || action === "unblock") {
-		const xWebResult = await runXWebAction(action, targetUserId);
-		if (xWebResult.ok) {
+		if (requestedTransport === "bird") {
+			return yield* runBirdActionEffect(action, query);
+		}
+		if (requestedTransport === "xurl") {
+			const accountCheck = yield* verifyXurlAccount();
+			if (accountCheck && typeof accountCheck === "object") {
+				return accountCheck;
+			}
+			return yield* runXurlActionEffect(
+				action,
+				query,
+				targetUserId,
+				typeof accountCheck === "string" ? accountCheck : null,
+			);
+		}
+
+		const birdResult = yield* runBirdActionEffect(action, query);
+		if (birdResult.ok) {
+			return birdResult;
+		}
+
+		const accountCheck = yield* verifyXurlAccount();
+		if (accountCheck && typeof accountCheck === "object") {
 			return {
-				...xWebResult,
+				ok: false,
 				output: [
-					xWebResult.output,
-					`falling back after ${normalizeFailure("bird", birdResult.output)}`,
-					`falling back after ${normalizeFailure("xurl", xurlResult.output)}`,
+					normalizeFailure("bird", birdResult.output),
+					normalizeFailure("xurl", accountCheck.output),
 				].join("\n"),
+				transport: "xurl",
+			};
+		}
+		const xurlResult = yield* runXurlActionEffect(
+			action,
+			query,
+			targetUserId,
+			typeof accountCheck === "string" ? accountCheck : null,
+		);
+		if (xurlResult.ok) {
+			return {
+				...xurlResult,
+				output: `${xurlResult.output}\nfalling back after ${normalizeFailure("bird", birdResult.output)}`,
 			};
 		}
 
@@ -211,20 +285,16 @@ export async function runModerationAction({
 			output: [
 				normalizeFailure("bird", birdResult.output),
 				normalizeFailure("xurl", xurlResult.output),
-				normalizeFailure("x-web", xWebResult.output),
 			].join("\n"),
-			transport: xWebResult.transport,
+			transport: xurlResult.transport,
 		};
-	}
-
-	return {
-		ok: false,
-		output: [
-			normalizeFailure("bird", birdResult.output),
-			normalizeFailure("xurl", xurlResult.output),
-		].join("\n"),
-		transport: xurlResult.transport,
-	};
+	});
+}
+
+export function runModerationAction(
+	params: RunActionParams,
+): Promise<ActionTransportResult> {
+	return runEffectPromise(runModerationActionEffect(params));
 }
 
 export type { ActionsTransport };

package/src/lib/api-client.ts

@@ -1,4 +1,6 @@
+import { Data, Effect } from "effect";
 import { z } from "zod";
+import { runEffectPromise } from "./effect-runtime";
 import type {
 	DmConversationItem,
 	DmMessageItem,
@@ -9,6 +11,7 @@ import type {
 import type {
 	WebSyncJobSnapshot,
 	WebSyncKind,
+	WebSyncOptions,
 	WebSyncResponse,
 } from "./web-sync";
 
@@ -103,15 +106,11 @@ const webSyncJobSchema = z
 const actionResponseSchema = jsonRecordSchema;
 const SYNC_POLL_INTERVAL_MS = 500;
 
-export class ApiFetchError extends Error {
-	constructor(
-		message: string,
-		readonly status?: number,
-	) {
-		super(message);
-		this.name = "ApiFetchError";
-	}
-}
+export class ApiFetchError extends Data.TaggedError("ApiFetchError")<{
+	readonly message: string;
+	readonly status?: number;
+	readonly cause?: unknown;
+}> {}
 
 function responseMessage(data: unknown, fallback: string) {
 	if (data && typeof data === "object") {
@@ -127,38 +126,77 @@ function responseMessage(data: unknown, fallback: string) {
 	return fallback;
 }
 
-async function readJson(response: Response) {
-	try {
-		return await response.json();
-	} catch {
-		return null;
+function apiFetchErrorFromCause(cause: unknown, fallbackMessage: string) {
+	if (cause instanceof DOMException && cause.name === "AbortError") {
+		return cause;
+	}
+	if (cause instanceof ApiFetchError) return cause;
+	if (cause instanceof Error) {
+		return new ApiFetchError({ message: cause.message, cause });
 	}
+	if (typeof cause === "string") {
+		return new ApiFetchError({ message: cause, cause });
+	}
+	return new ApiFetchError({ message: fallbackMessage, cause });
+}
+
+function readJsonEffect(response: Response) {
+	return Effect.promise(() => response.json().catch(() => null as unknown));
+}
+
+function runApiEffect<T, E>(effect: Effect.Effect<T, E>) {
+	return runEffectPromise(effect);
 }
 
-export async function fetchJson<T>(
+export function fetchJsonEffect<T>(
 	input: RequestInfo | URL,
 	init: RequestInit | undefined,
 	schema: z.ZodType<T>,
 	fallbackMessage: string,
-): Promise<T> {
-	const response = await fetch(input, init);
-	const data = await readJson(response);
-	if (!response.ok) {
-		throw new ApiFetchError(
-			responseMessage(data, fallbackMessage),
-			response.status,
-		);
-	}
+) {
+	return Effect.gen(function* () {
+		const response = yield* Effect.tryPromise({
+			try: () => fetch(input, init),
+			catch: (cause) => apiFetchErrorFromCause(cause, fallbackMessage),
+		});
+		const data = yield* readJsonEffect(response);
+		if (!response.ok) {
+			return yield* Effect.fail(
+				new ApiFetchError({
+					message: responseMessage(data, fallbackMessage),
+					status: response.status,
+				}),
+			);
+		}
 
-	const parsed = schema.safeParse(data);
-	if (!parsed.success) {
-		throw new ApiFetchError(fallbackMessage);
-	}
-	return parsed.data;
+		const parsed = schema.safeParse(data);
+		if (!parsed.success) {
+			return yield* Effect.fail(
+				new ApiFetchError({
+					message: fallbackMessage,
+					cause: parsed.error,
+				}),
+			);
+		}
+		return parsed.data;
+	});
+}
+
+export function fetchJson<T>(
+	input: RequestInfo | URL,
+	init: RequestInit | undefined,
+	schema: z.ZodType<T>,
+	fallbackMessage: string,
+): Promise<T> {
+	return runApiEffect(fetchJsonEffect(input, init, schema, fallbackMessage));
 }
 
 export function fetchQueryEnvelope(init?: RequestInit) {
-	return fetchJson(
+	return runApiEffect(fetchQueryEnvelopeEffect(init));
+}
+
+export function fetchQueryEnvelopeEffect(init?: RequestInit) {
+	return fetchJsonEffect(
 		"/api/status",
 		init,
 		queryEnvelopeSchema,
@@ -170,11 +208,22 @@ export function fetchQueryResponse(
 	input: RequestInfo | URL,
 	init?: RequestInit,
 ) {
-	return fetchJson(input, init, queryResponseSchema, "Query unavailable");
+	return runApiEffect(fetchQueryResponseEffect(input, init));
+}
+
+export function fetchQueryResponseEffect(
+	input: RequestInfo | URL,
+	init?: RequestInit,
+) {
+	return fetchJsonEffect(input, init, queryResponseSchema, "Query unavailable");
 }
 
 export function postAction(body: Record<string, unknown>) {
-	return fetchJson(
+	return runApiEffect(postActionEffect(body));
+}
+
+export function postActionEffect(body: Record<string, unknown>) {
+	return fetchJsonEffect(
 		"/api/action",
 		{
 			method: "POST",
@@ -186,8 +235,20 @@ export function postAction(body: Record<string, unknown>) {
 	);
 }
 
-export function postSync(kind: WebSyncKind, accountId?: string) {
-	return fetchJson(
+export function postSync(
+	kind: WebSyncKind,
+	accountId?: string,
+	options: WebSyncOptions = {},
+) {
+	return runApiEffect(postSyncEffect(kind, accountId, options));
+}
+
+export function postSyncEffect(
+	kind: WebSyncKind,
+	accountId?: string,
+	options: WebSyncOptions = {},
+) {
+	return fetchJsonEffect(
 		"/api/sync",
 		{
 			method: "POST",
@@ -195,35 +256,49 @@ export function postSync(kind: WebSyncKind, accountId?: string) {
 			body: JSON.stringify({
 				kind,
 				...(accountId ? { accountId } : {}),
+				...options,
 			}),
 		},
 		webSyncJobSchema,
 		"Sync failed",
-	).then(waitForWebSyncJob);
+	).pipe(Effect.flatMap(waitForWebSyncJobEffect));
 }
 
-function fetchSyncJob(id: string) {
+function fetchSyncJobEffect(id: string) {
 	const url = new URL("/api/sync", window.location.origin);
 	url.searchParams.set("id", id);
-	return fetchJson(url, undefined, webSyncJobSchema, "Sync status unavailable");
+	return fetchJsonEffect(
+		url,
+		undefined,
+		webSyncJobSchema,
+		"Sync status unavailable",
+	);
 }
 
-function delay(ms: number) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
+export function waitForWebSyncJobEffect(job: WebSyncJobSnapshot) {
+	return Effect.gen(function* () {
+		let current = job;
+		while (current.inProgress) {
+			yield* Effect.sleep(SYNC_POLL_INTERVAL_MS);
+			current = yield* fetchSyncJobEffect(current.id);
+		}
 
-async function waitForWebSyncJob(job: WebSyncJobSnapshot) {
-	let current = job;
-	while (current.inProgress) {
-		await delay(SYNC_POLL_INTERVAL_MS);
-		current = await fetchSyncJob(current.id);
-	}
+		if (!current.result) {
+			return yield* Effect.fail(
+				new ApiFetchError({ message: current.error ?? current.summary }),
+			);
+		}
+		if (!current.result.ok) {
+			return yield* Effect.fail(
+				new ApiFetchError({
+					message: current.result.error ?? current.result.summary,
+				}),
+			);
+		}
+		return current.result;
+	});
+}
 
-	if (!current.result) {
-		throw new ApiFetchError(current.error ?? current.summary);
-	}
-	if (!current.result.ok) {
-		throw new ApiFetchError(current.result.error ?? current.result.summary);
-	}
-	return current.result;
+export function waitForWebSyncJob(job: WebSyncJobSnapshot) {
+	return runApiEffect(waitForWebSyncJobEffect(job));
 }