birdclaw 0.5.0 → 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 };