@abraca/resend 2.16.0

package/src/server.ts

@@ -0,0 +1,322 @@
+/**
+ * AbracadabraResendServer — connection lifecycle for the Resend bridge.
+ *
+ * Trimmed-down equivalent of @abraca/mcp's server: Ed25519 identity, login/
+ * register, single-space binding, child-provider cache with idle eviction,
+ * `ensureConnected` heal on dropped sockets / expired JWTs. No awareness,
+ * no chat, no tool wiring — this is a daemon, not an agent.
+ */
+import type { DocumentMeta, ServerInfo } from "@abraca/dabra";
+import {
+	AbracadabraClient,
+	AbracadabraProvider,
+	Kind,
+	SERVER_ROOT_ID,
+	WebSocketStatus,
+} from "@abraca/dabra";
+import * as Y from "yjs";
+import { loadOrCreateKeypair, signChallenge } from "./crypto.ts";
+import { waitForSync } from "./utils.ts";
+
+export interface ResendServerConfig {
+	url: string;
+	agentName?: string;
+	keyFile?: string;
+	inviteCode?: string;
+	/** Bind to this space id. When omitted, the first visible space is used. */
+	spaceId?: string;
+}
+
+interface SpaceConnection {
+	doc: Y.Doc;
+	provider: AbracadabraProvider;
+	docId: string;
+}
+
+interface CachedProvider {
+	provider: AbracadabraProvider;
+	lastAccessed: number;
+}
+
+const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+
+export class AbracadabraResendServer {
+	readonly config: ResendServerConfig;
+	readonly client: AbracadabraClient;
+	private _serverInfo: ServerInfo | null = null;
+	private _spaces: DocumentMeta[] = [];
+	private _connection: SpaceConnection | null = null;
+	private childCache = new Map<string, CachedProvider>();
+	private evictionTimer: ReturnType<typeof setInterval> | null = null;
+	private _userId: string | null = null;
+	private _signFn: ((challenge: string) => Promise<string>) | null = null;
+	private _reconnecting: Promise<void> | null = null;
+
+	constructor(config: ResendServerConfig) {
+		this.config = config;
+		this.client = new AbracadabraClient({
+			url: config.url,
+			persistAuth: false,
+		});
+	}
+
+	get agentName(): string {
+		return this.config.agentName || "Resend Bridge";
+	}
+
+	get serverInfo(): ServerInfo | null {
+		return this._serverInfo;
+	}
+
+	get spaceDocId(): string | null {
+		return this._connection?.docId ?? null;
+	}
+
+	get rootDocument(): Y.Doc | null {
+		return this._connection?.doc ?? null;
+	}
+
+	get rootProvider(): AbracadabraProvider | null {
+		return this._connection?.provider ?? null;
+	}
+
+	get userId(): string | null {
+		return this._userId;
+	}
+
+	get spaces(): DocumentMeta[] {
+		return this._spaces;
+	}
+
+	/** Authenticate, discover spaces, connect to the configured (or first) space. */
+	async connect(): Promise<void> {
+		const keypair = await loadOrCreateKeypair(this.config.keyFile);
+		this._userId = keypair.publicKeyB64;
+		const signFn = (challenge: string) =>
+			Promise.resolve(signChallenge(challenge, keypair.privateKey));
+		this._signFn = signFn;
+
+		try {
+			await this.client.loginWithKey(keypair.publicKeyB64, signFn);
+		} catch (err: any) {
+			const status = err?.status ?? err?.response?.status;
+			const msg = String(err?.message ?? "").toLowerCase();
+			const notRegistered =
+				status === 404 ||
+				status === 422 ||
+				(status === 401 &&
+					/not registered|user not found|no such user/.test(msg));
+			if (!notRegistered) throw err;
+			console.error(
+				"[abracadabra-resend] Key not registered, creating new account...",
+			);
+			await this.client.registerWithKey({
+				publicKey: keypair.publicKeyB64,
+				username: this.agentName.replace(/\s+/g, "-").toLowerCase(),
+				displayName: this.agentName,
+				deviceName: "Resend Bridge",
+				inviteCode: this.config.inviteCode,
+			});
+			await this.client.loginWithKey(keypair.publicKeyB64, signFn);
+		}
+		console.error(
+			`[abracadabra-resend] Authenticated as ${this.agentName} (pubkey=${keypair.publicKeyB64})`,
+		);
+
+		this._serverInfo = await this.client.serverInfo();
+
+		const roots = await this.client.listChildren();
+		this._spaces = roots.filter((d) => d.kind === Kind.Space);
+
+		let targetId = this.config.spaceId;
+		if (targetId) {
+			const found =
+				this._spaces.find((s) => s.id === targetId) ??
+				roots.find((d) => d.id === targetId);
+			if (!found) {
+				throw new Error(
+					`Configured ABRA_SPACE_ID=${targetId} not found among server roots`,
+				);
+			}
+		} else {
+			targetId = this._spaces[0]?.id ?? roots[0]?.id;
+			if (!targetId) {
+				throw new Error(
+					`No entry point found: server has no top-level documents under ${SERVER_ROOT_ID}.`,
+				);
+			}
+		}
+
+		console.error(`[abracadabra-resend] Binding to space ${targetId}`);
+		await this._connectToSpace(targetId);
+		console.error("[abracadabra-resend] Space doc synced");
+
+		this.evictionTimer = setInterval(() => this.evictIdle(), 60_000);
+	}
+
+	private async _connectToSpace(docId: string): Promise<SpaceConnection> {
+		if (!this.client.isTokenValid() && this._signFn && this._userId) {
+			console.error("[abracadabra-resend] JWT expired, re-authenticating...");
+			await this.client.loginWithKey(this._userId, this._signFn);
+		}
+
+		const doc = new Y.Doc({ guid: docId });
+		const provider = new AbracadabraProvider({
+			name: docId,
+			document: doc,
+			client: this.client,
+			disableOfflineStore: true,
+			subdocLoading: "lazy",
+		});
+
+		await waitForSync(provider);
+
+		provider.awareness?.setLocalStateField("user", {
+			name: this.agentName,
+			color: "hsl(170, 70%, 45%)",
+			publicKey: this._userId,
+			isAgent: true,
+		});
+
+		const conn: SpaceConnection = { doc, provider, docId };
+		this._connection = conn;
+		return conn;
+	}
+
+	private _wsConnected(provider: AbracadabraProvider): boolean {
+		return provider.connectionStatus === WebSocketStatus.Connected;
+	}
+
+	/**
+	 * Heal a dropped socket / expired JWT before tool ops. De-duped across
+	 * concurrent callers; best-effort (never throws — a failed heal falls
+	 * through to the caller's normal error handling).
+	 */
+	async ensureConnected(): Promise<void> {
+		if (this._reconnecting) return this._reconnecting;
+		this._reconnecting = (async () => {
+			try {
+				if (!this.client.isTokenValid() && this._signFn && this._userId) {
+					try {
+						await this.client.loginWithKey(this._userId, this._signFn);
+					} catch (e) {
+						console.error("[abracadabra-resend] Re-auth during heal failed:", e);
+					}
+				}
+				const conn = this._connection;
+				if (!conn) return;
+				if (this._wsConnected(conn.provider)) return;
+				try {
+					await waitForSync(conn.provider, 6000);
+				} catch {
+					/* fall through to rebuild */
+				}
+				if (this._wsConnected(conn.provider)) return;
+
+				console.error(
+					"[abracadabra-resend] Active connection dead — rebuilding…",
+				);
+				const docId = conn.docId;
+				try {
+					conn.provider.destroy();
+				} catch {
+					/* already gone */
+				}
+				for (const [, cached] of this.childCache) {
+					try {
+						cached.provider.destroy();
+					} catch {
+						/* already gone */
+					}
+				}
+				this.childCache.clear();
+				try {
+					await this._connectToSpace(docId);
+					console.error("[abracadabra-resend] Space provider rebuilt + synced");
+				} catch (e) {
+					console.error("[abracadabra-resend] Connection rebuild failed:", e);
+				}
+			} finally {
+				this._reconnecting = null;
+			}
+		})();
+		return this._reconnecting;
+	}
+
+	getTreeMap(): Y.Map<any> | null {
+		return this._connection?.doc.getMap("doc-tree") ?? null;
+	}
+
+	async getChildProvider(docId: string): Promise<AbracadabraProvider> {
+		await this.ensureConnected();
+
+		const cached = this.childCache.get(docId);
+		if (
+			cached &&
+			cached.provider.connectionStatus !== WebSocketStatus.Disconnected
+		) {
+			cached.lastAccessed = Date.now();
+			return cached.provider;
+		}
+		if (cached) {
+			try {
+				cached.provider.destroy();
+			} catch {
+				/* already gone */
+			}
+			this.childCache.delete(docId);
+		}
+
+		const root = this._connection?.provider;
+		if (!root) throw new Error("Not connected. Call connect() first.");
+
+		if (!this.client.isTokenValid() && this._signFn && this._userId) {
+			await this.client.loginWithKey(this._userId, this._signFn);
+		}
+
+		const childProvider = await root.loadChild(docId);
+		await waitForSync(childProvider);
+
+		this.childCache.set(docId, {
+			provider: childProvider,
+			lastAccessed: Date.now(),
+		});
+
+		return childProvider;
+	}
+
+	private evictIdle(): void {
+		const now = Date.now();
+		for (const [docId, cached] of this.childCache) {
+			if (now - cached.lastAccessed > IDLE_TIMEOUT_MS) {
+				cached.provider.destroy();
+				this.childCache.delete(docId);
+				console.error(`[abracadabra-resend] Evicted idle provider: ${docId}`);
+			}
+		}
+	}
+
+	async destroy(): Promise<void> {
+		if (this.evictionTimer) {
+			clearInterval(this.evictionTimer);
+			this.evictionTimer = null;
+		}
+		for (const [, cached] of this.childCache) {
+			try {
+				cached.provider.destroy();
+			} catch {
+				/* already gone */
+			}
+		}
+		this.childCache.clear();
+		if (this._connection) {
+			try {
+				this._connection.provider.destroy();
+			} catch {
+				/* already gone */
+			}
+			this._connection = null;
+		}
+		console.error("[abracadabra-resend] Shutdown complete");
+	}
+}

package/src/utils.ts

@@ -0,0 +1,32 @@
+/**
+ * Wait for a provider's `synced` event with a timeout.
+ *
+ * The `isSynced` short-circuit is load-bearing: providers that already synced
+ * (e.g. cached child providers returned from `loadChild`) won't re-emit
+ * `synced`, so without the short-circuit every later op on that doc times out.
+ */
+export function waitForSync(
+	provider: {
+		isSynced?: boolean;
+		on(event: string, cb: () => void): void;
+		off(event: string, cb: () => void): void;
+	},
+	timeoutMs = 15000,
+): Promise<void> {
+	if (provider.isSynced) return Promise.resolve();
+
+	return new Promise<void>((resolve, reject) => {
+		const timer = setTimeout(() => {
+			provider.off("synced", handler);
+			reject(new Error(`Sync timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+
+		function handler() {
+			clearTimeout(timer);
+			provider.off("synced", handler);
+			resolve();
+		}
+
+		provider.on("synced", handler);
+	});
+}