@pstdio/pocketcoder-remote 0.2.0

package/src/extension.ts

@@ -0,0 +1,200 @@
+import {
+	type Api,
+	type AssistantMessage,
+	type AssistantMessageEventStream,
+	type Context,
+	createAssistantMessageEventStream,
+	type Model,
+} from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	collectTurnFiles,
+	DIRECT_MODE_ATTACHMENT_ERROR,
+	registerAttachCommand,
+	uploadTurnFiles,
+	userTextOf,
+} from "./attachments";
+import { RemoteAgentClient } from "./client";
+import { registerWorkspaceCommands } from "./commands";
+import { ControlPlaneClient } from "./control-plane";
+import { replayHistory } from "./history";
+import { registerConversationRenderers } from "./renderers";
+import { emitRemoteResponse } from "./response-stream";
+import { relayTarget, TargetRef, targetFromEnvironment } from "./session-target";
+import { STATUS_KEY, StatusPoller } from "./status";
+
+const PROVIDER = "pocketcoder-agentapi";
+const MODEL = "remote-agent";
+
+function emptyUsage(): AssistantMessage["usage"] {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+	};
+}
+
+function remoteStream(
+	targets: TargetRef,
+	controlPlane: ControlPlaneClient | undefined,
+	attachmentQueue: string[],
+	model: Model<Api>,
+	context: Context,
+	signal?: AbortSignal,
+	onOutputStart?: () => void,
+): AssistantMessageEventStream {
+	const stream = createAssistantMessageEventStream();
+	const output: AssistantMessage = {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: emptyUsage(),
+		stopReason: "pending",
+		timestamp: Date.now(),
+	};
+
+	void (async () => {
+		stream.push({ type: "start", partial: output });
+		try {
+			const target = targets.current;
+			if (target.mode === "unset") {
+				throw new Error("no workspace attached; run /workspace or /workspace-create first");
+			}
+			const files = collectTurnFiles(context, attachmentQueue);
+			if (files.length > 0 && (target.mode !== "relay" || !controlPlane)) {
+				throw new Error(DIRECT_MODE_ATTACHMENT_ERROR);
+			}
+			let attachmentIds: string[] = [];
+			if (files.length > 0 && target.mode === "relay" && controlPlane) {
+				attachmentIds = await uploadTurnFiles(controlPlane, target.workspaceId, files);
+				attachmentQueue.length = 0;
+			}
+			const client = new RemoteAgentClient({ serviceUrl: target.serviceUrl, key: target.key });
+			await emitRemoteResponse(
+				stream,
+				output,
+				async (onSnapshot) =>
+					await client.send(userTextOf(context), signal, attachmentIds, onSnapshot),
+				onOutputStart,
+			);
+		} catch (error) {
+			output.stopReason = signal?.aborted ? "aborted" : "error";
+			output.errorMessage = error instanceof Error ? error.message : String(error);
+			stream.push({ type: "error", reason: output.stopReason, error: output });
+		} finally {
+			stream.end();
+		}
+	})();
+
+	return stream;
+}
+
+async function pickInitialWorkspace(
+	controlPlane: ControlPlaneClient,
+	targets: TargetRef,
+	context: ExtensionContext,
+): Promise<void> {
+	const target = targets.current;
+	if (target.mode !== "unset" || !context.hasUI) return;
+	const workspaces = (await controlPlane.workspaces.list({ state: "ready" })).items;
+	if (workspaces.length === 0) {
+		context.ui.notify("no ready workspaces; run /workspace-create", "warning");
+		return;
+	}
+	const labels = workspaces.map(
+		(workspace) =>
+			`${workspace.external_id} · ${workspace.template.name} · ${workspace.id.slice(0, 8)}`,
+	);
+	const selection = await context.ui.select("Attach to workspace", labels);
+	if (selection === undefined) {
+		context.ui.notify("no workspace attached; run /workspace to attach", "warning");
+		return;
+	}
+	const workspace = workspaces[labels.indexOf(selection)];
+	if (workspace) targets.set(relayTarget(target.baseUrl, target.key, workspace.id));
+}
+
+export default function (pi: ExtensionAPI): void {
+	const targets = new TargetRef(targetFromEnvironment());
+	const initial = targets.current;
+	const controlPlane =
+		initial.mode === "direct"
+			? undefined
+			: new ControlPlaneClient({ baseUrl: initial.baseUrl, key: initial.key });
+	const attachmentQueue: string[] = [];
+	let poller: StatusPoller | undefined;
+	let activeContext: ExtensionContext | undefined;
+
+	pi.registerProvider(PROVIDER, {
+		name: "PocketCoder remote agent",
+		baseUrl: initial.mode === "direct" ? initial.serviceUrl : initial.baseUrl,
+		apiKey: "local-ui",
+		api: "openai-completions",
+		models: [
+			{
+				id: MODEL,
+				name: "PocketCoder remote agent",
+				reasoning: false,
+				input: ["text", "image"],
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+				contextWindow: 1_000_000,
+				maxTokens: 100_000,
+			},
+		],
+		streamSimple: (model, context, options) =>
+			remoteStream(targets, controlPlane, attachmentQueue, model, context, options?.signal, () =>
+				activeContext?.ui.setWorkingVisible(false),
+			),
+	});
+
+	registerConversationRenderers(pi);
+	registerAttachCommand(pi, { targets, queue: attachmentQueue });
+	if (controlPlane) registerWorkspaceCommands(pi, { targets, controlPlane });
+
+	pi.on("session_start", async (_event, context) => {
+		activeContext = context;
+		pi.setActiveTools([]);
+		await poller?.stop();
+		poller = undefined;
+
+		if (controlPlane) await pickInitialWorkspace(controlPlane, targets, context);
+		const target = targets.current;
+		if (target.mode === "direct") {
+			context.ui.setStatus(STATUS_KEY, "direct agentapi");
+			return;
+		}
+		if (target.mode === "unset") {
+			context.ui.setStatus(STATUS_KEY, "no workspace");
+			return;
+		}
+		context.ui.setStatus(STATUS_KEY, `ws ${target.workspaceId.slice(0, 8)}`);
+		if (!controlPlane) return;
+		try {
+			const workspace = await controlPlane.workspaces.get(target.workspaceId);
+			await replayHistory(pi, controlPlane, target.workspaceId);
+			poller = new StatusPoller(controlPlane, workspace, context.ui);
+			poller.start();
+		} catch (error) {
+			context.ui.notify(
+				`could not load workspace history: ${error instanceof Error ? error.message : String(error)}`,
+				"warning",
+			);
+		}
+	});
+
+	pi.on("turn_start", async () => poller?.pause());
+	pi.on("turn_end", async (_event, context) => {
+		context.ui.setWorkingVisible(true);
+		poller?.resume();
+	});
+	pi.on("session_shutdown", async () => {
+		await poller?.stop();
+		poller = undefined;
+		activeContext = undefined;
+	});
+}

package/src/history.ts

@@ -0,0 +1,112 @@
+import type { ControlPlaneClient } from "./control-plane";
+import { ConversationGoneError } from "./control-plane";
+import {
+	type ConversationEntryData,
+	HISTORY_ENTRY_TYPE,
+	type HistoryNoticeData,
+	NOTICE_ENTRY_TYPE,
+} from "./renderers";
+
+export interface ReplayOptions {
+	pageLimit?: number;
+	maxMessages?: number;
+	maxPages?: number;
+}
+
+export interface ReplayOutcome {
+	replayed: number;
+	total: number;
+	truncated: boolean;
+	gone: boolean;
+}
+
+export interface EntrySink {
+	appendEntry<T = unknown>(customType: string, data?: T): void;
+}
+
+/**
+ * Replays the workspace's durable conversation into the local session as
+ * custom entries. The server transcript is the source of truth: this runs on
+ * every attach, and entries never participate in LLM context.
+ */
+interface TranscriptTail {
+	tail: ConversationEntryData[];
+	total: number;
+	pages: number;
+	exhaustedPages: boolean;
+}
+
+async function collectTranscriptTail(
+	controlPlane: ControlPlaneClient,
+	workspaceId: string,
+	options: Required<ReplayOptions>,
+): Promise<TranscriptTail> {
+	const tail: ConversationEntryData[] = [];
+	let total = 0;
+	let pages = 0;
+	let cursor: string | undefined;
+	while (pages < options.maxPages) {
+		const page = await controlPlane.conversations.list(workspaceId, {
+			cursor,
+			limit: options.pageLimit,
+		});
+		pages += 1;
+		for (const message of page.items) {
+			total += 1;
+			tail.push({
+				role: message.role,
+				content: message.content,
+				seq: message.seq,
+				occurred_at: message.occurred_at,
+				kind: message.metadata?.kind,
+				metadata: message.metadata,
+			});
+			if (tail.length > options.maxMessages) tail.shift();
+		}
+		if (page.nextCursor === null) return { tail, total, pages, exhaustedPages: false };
+		cursor = page.nextCursor;
+	}
+	return { tail, total, pages, exhaustedPages: true };
+}
+
+export async function replayHistory(
+	pi: EntrySink,
+	controlPlane: ControlPlaneClient,
+	workspaceId: string,
+	options: ReplayOptions = {},
+): Promise<ReplayOutcome> {
+	let transcript: TranscriptTail;
+	try {
+		transcript = await collectTranscriptTail(controlPlane, workspaceId, {
+			pageLimit: options.pageLimit ?? 200,
+			maxMessages: options.maxMessages ?? 1000,
+			maxPages: options.maxPages ?? 50,
+		});
+	} catch (error) {
+		if (error instanceof ConversationGoneError) {
+			pi.appendEntry<HistoryNoticeData>(NOTICE_ENTRY_TYPE, {
+				text:
+					error.code === "conversation.deleted"
+						? "conversation history was deleted"
+						: "conversation history has expired",
+				level: "warning",
+			});
+			return { replayed: 0, total: 0, truncated: false, gone: true };
+		}
+		throw error;
+	}
+
+	const { tail, total, pages, exhaustedPages } = transcript;
+	const truncated = total > tail.length || exhaustedPages;
+	if (truncated) {
+		pi.appendEntry<HistoryNoticeData>(NOTICE_ENTRY_TYPE, {
+			text: exhaustedPages
+				? `history partially replayed (stopped after ${pages} pages)`
+				: `showing last ${tail.length} of ${total} messages`,
+		});
+	}
+	for (const message of tail) {
+		pi.appendEntry<ConversationEntryData>(HISTORY_ENTRY_TYPE, message);
+	}
+	return { replayed: tail.length, total, truncated, gone: false };
+}

package/src/launch.ts

@@ -0,0 +1,85 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export interface PiInvocation {
+	command: string;
+	args: string[];
+	env: NodeJS.ProcessEnv;
+}
+
+export interface ResolveOptions {
+	env?: NodeJS.ProcessEnv;
+	argv?: string[];
+	execPath?: string;
+	resolvePath?: (specifier: string) => string;
+}
+
+const PI_FLAGS = [
+	"--provider",
+	"pocketcoder-agentapi",
+	"--model",
+	"remote-agent",
+	"--api-key",
+	"local-ui",
+	"--no-tools",
+	"--no-extensions",
+	"--no-skills",
+	"--no-context-files",
+	"--no-prompt-templates",
+	"--no-session",
+	"--offline",
+];
+
+function piBinPath(resolvePath: (specifier: string) => string): string {
+	// The package's exports map hides ./package.json, so locate the package
+	// root from its resolved main entry instead.
+	const entry = resolvePath("@earendil-works/pi-coding-agent");
+	const marker = `${sep}pi-coding-agent${sep}`;
+	const index = entry.lastIndexOf(marker);
+	if (index === -1) {
+		throw new Error(`could not locate @earendil-works/pi-coding-agent from ${entry}`);
+	}
+	const packageRoot = entry.slice(0, index + marker.length - 1);
+	const manifest = JSON.parse(readFileSync(resolve(packageRoot, "package.json"), "utf8")) as {
+		bin?: Record<string, string>;
+	};
+	const bin = manifest.bin?.pi;
+	if (!bin) throw new Error("@earendil-works/pi-coding-agent does not declare a pi bin");
+	return resolve(packageRoot, bin);
+}
+
+function extensionPath(): string {
+	// Works from both src/bin.ts (dev) and dist/bin.js (published): the
+	// package root is one directory up in both layouts.
+	const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+	return resolve(packageRoot, "src/extension.ts");
+}
+
+export function resolvePiInvocation(options: ResolveOptions = {}): PiInvocation {
+	const env = options.env ?? process.env;
+	if (!env.POCKETCODER_KEY) {
+		throw new Error(
+			"POCKETCODER_KEY is required. Issue a machine key with `pcd keys issue` and export it, along with POCKETCODER_URL for your PocketCoder server.",
+		);
+	}
+	// The pi package's exports map only defines the "import" condition, so
+	// resolution must go through ESM resolve, not createRequire.
+	const resolvePath =
+		options.resolvePath ?? ((specifier: string) => fileURLToPath(import.meta.resolve(specifier)));
+	const childEnv: NodeJS.ProcessEnv = { ...env };
+	// Pi must never talk to a model provider directly; every turn goes
+	// through the PocketCoder relay.
+	delete childEnv.OPENAI_API_KEY;
+	return {
+		command: options.execPath ?? process.execPath,
+		args: [
+			piBinPath(resolvePath),
+			...PI_FLAGS,
+			"--extension",
+			extensionPath(),
+			...(options.argv ?? []),
+		],
+		env: childEnv,
+	};
+}

package/src/renderers.ts

@@ -0,0 +1,76 @@
+import type { ExtensionAPI, ThemeColor } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { splitAttachmentManifest } from "@pstdio/pocketcoder-client";
+
+export const HISTORY_ENTRY_TYPE = "pocketcoder-conversation";
+export const NOTICE_ENTRY_TYPE = "pocketcoder-history-notice";
+
+export interface ConversationEntryData {
+	role: string;
+	content: string;
+	seq: number;
+	occurred_at: string;
+	/** Reserved for future typed payloads (tool_use, permission_request, ...). */
+	kind?: string;
+	metadata?: Record<string, string>;
+}
+
+export interface HistoryNoticeData {
+	text: string;
+	level?: "info" | "warning";
+}
+
+/** The slice of Pi's Theme the formatters use; Theme satisfies it structurally. */
+export interface ThemeLike {
+	fg(color: ThemeColor, text: string): string;
+	bold(text: string): string;
+}
+
+function roleHeader(data: ConversationEntryData, theme: ThemeLike): string {
+	const time = data.occurred_at.replace("T", " ").replace(/\.\d+Z?$|Z$/, "");
+	return theme.fg("muted", `${data.role} · ${time}`);
+}
+
+// User messages may end in the generated attachment manifest; history shows
+// the attachment names instead of the raw markup and managed paths.
+function userBody(content: string, theme: ThemeLike): string {
+	const { text, attachments } = splitAttachmentManifest(content);
+	const body = theme.fg("userMessageText", text);
+	if (!attachments) return body;
+	const list = attachments
+		.map((attachment) => theme.fg("muted", `⌁ ${attachment.name} (${attachment.size_bytes} bytes)`))
+		.join("\n");
+	return `${body}\n${list}`;
+}
+
+export function formatConversationMessage(data: ConversationEntryData, theme: ThemeLike): string {
+	switch (data.kind ?? "text") {
+		// Future typed kinds (tool_use, permission_request, ...) become new cases;
+		// unknown kinds deliberately fall through to the text rendering.
+		default: {
+			const header = roleHeader(data, theme);
+			const body =
+				data.role === "user"
+					? userBody(data.content, theme)
+					: data.role === "assistant"
+						? data.content
+						: theme.fg("dim", data.content);
+			return `${header}\n${body}`;
+		}
+	}
+}
+
+export function formatHistoryNotice(data: HistoryNoticeData, theme: ThemeLike): string {
+	return theme.fg(data.level === "warning" ? "warning" : "muted", data.text);
+}
+
+export function registerConversationRenderers(pi: ExtensionAPI): void {
+	pi.registerEntryRenderer<ConversationEntryData>(HISTORY_ENTRY_TYPE, (entry, _options, theme) => {
+		if (!entry.data) return undefined;
+		return new Text(formatConversationMessage(entry.data, theme), 1, 0);
+	});
+	pi.registerEntryRenderer<HistoryNoticeData>(NOTICE_ENTRY_TYPE, (entry, _options, theme) => {
+		if (!entry.data) return undefined;
+		return new Text(formatHistoryNotice(entry.data, theme), 1, 0);
+	});
+}

package/src/response-stream.ts

@@ -0,0 +1,43 @@
+import type { AssistantMessage, AssistantMessageEventStream } from "@earendil-works/pi-ai";
+
+type AssistantEvent = Parameters<AssistantMessageEventStream["push"]>[0];
+
+export interface AssistantEventSink {
+	push(event: AssistantEvent): void;
+}
+
+function textOf(message: AssistantMessage): string {
+	const content = message.content[0];
+	return content?.type === "text" ? content.text : "";
+}
+
+export async function emitRemoteResponse(
+	stream: AssistantEventSink,
+	output: AssistantMessage,
+	send: (onSnapshot: (snapshot: string) => void) => Promise<string>,
+	onOutputStart: () => void = () => {},
+): Promise<void> {
+	let previous = "";
+	let started = false;
+	const update = (snapshot: string) => {
+		if (snapshot === previous) return;
+		const delta = snapshot.startsWith(previous) ? snapshot.slice(previous.length) : "";
+		if (!started) {
+			output.content.push({ type: "text", text: "" });
+			started = true;
+			onOutputStart();
+			stream.push({ type: "text_start", contentIndex: 0, partial: output });
+		}
+		const content = output.content[0];
+		if (content?.type === "text") content.text = snapshot;
+		previous = snapshot;
+		stream.push({ type: "text_delta", contentIndex: 0, delta, partial: output });
+	};
+
+	const final = await send(update);
+	update(final);
+	if (!started) update("");
+	stream.push({ type: "text_end", contentIndex: 0, content: textOf(output), partial: output });
+	output.stopReason = "stop";
+	stream.push({ type: "done", reason: "stop", message: output });
+}

package/src/session-target.ts

@@ -0,0 +1,66 @@
+export interface RelayTarget {
+	mode: "relay";
+	baseUrl: string;
+	key: string;
+	workspaceId: string;
+	serviceUrl: string;
+}
+
+export interface DirectTarget {
+	mode: "direct";
+	key: string;
+	serviceUrl: string;
+}
+
+export interface UnsetTarget {
+	mode: "unset";
+	baseUrl: string;
+	key: string;
+}
+
+export type SessionTarget = RelayTarget | DirectTarget | UnsetTarget;
+
+export function relayTarget(baseUrl: string, key: string, workspaceId: string): RelayTarget {
+	const base = baseUrl.replace(/\/$/, "");
+	return {
+		mode: "relay",
+		baseUrl: base,
+		key,
+		workspaceId,
+		serviceUrl: `${base}/v1/workspaces/${encodeURIComponent(workspaceId)}/agent`,
+	};
+}
+
+export function targetFromEnvironment(env: NodeJS.ProcessEnv = process.env): SessionTarget {
+	const key = env.POCKETCODER_KEY;
+	if (!key) throw new Error("POCKETCODER_KEY is required");
+	const directUrl = env.POCKETCODER_AGENTAPI_URL;
+	if (directUrl) return { mode: "direct", key, serviceUrl: directUrl.replace(/\/$/, "") };
+
+	const baseUrl = (env.POCKETCODER_URL ?? "http://127.0.0.1:7080").replace(/\/$/, "");
+	const workspaceId = env.POCKETCODER_WORKSPACE_ID;
+	if (!workspaceId) return { mode: "unset", baseUrl, key };
+	return relayTarget(baseUrl, key, workspaceId);
+}
+
+export class TargetRef {
+	private target: SessionTarget;
+	private readonly listeners: Array<(target: SessionTarget) => void> = [];
+
+	constructor(initial: SessionTarget) {
+		this.target = initial;
+	}
+
+	get current(): SessionTarget {
+		return this.target;
+	}
+
+	set(next: SessionTarget): void {
+		this.target = next;
+		for (const listener of this.listeners) listener(next);
+	}
+
+	onChange(listener: (target: SessionTarget) => void): void {
+		this.listeners.push(listener);
+	}
+}

package/src/status.ts

@@ -0,0 +1,121 @@
+import type { ControlPlaneClient, WorkspaceSummary } from "./control-plane";
+import { TERMINAL_WORKSPACE_STATES } from "./control-plane";
+
+export const STATUS_KEY = "pocketcoder";
+
+export interface StatusUi {
+	setStatus(key: string, text: string | undefined): void;
+	notify(message: string, type?: "info" | "warning" | "error"): void;
+}
+
+export interface StatusPollerOptions {
+	waitSeconds?: number;
+	delay?: (ms: number) => Promise<void>;
+}
+
+export function statusText(
+	workspace: Pick<WorkspaceSummary, "id" | "state" | "agent_state">,
+): string {
+	return `ws ${workspace.id.slice(0, 8)} · ${workspace.state}/${workspace.agent_state}`;
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Keeps the status bar in sync with the workspace via the durable change
+ * cursor. Paused during turns so RemoteAgentClient.send() is the only
+ * consumer of the change feed while the agent is working.
+ */
+export class StatusPoller {
+	private readonly controlPlane: ControlPlaneClient;
+	private readonly workspaceId: string;
+	private readonly ui: StatusUi;
+	private readonly waitSeconds: number;
+	private readonly delay: (ms: number) => Promise<void>;
+	private cursor: number;
+	private paused = false;
+	private stopped = false;
+	private wake: (() => void) | undefined;
+	private controller: AbortController | undefined;
+	private loop: Promise<void> | undefined;
+	private lastText: string | undefined;
+
+	constructor(
+		controlPlane: ControlPlaneClient,
+		workspace: Pick<WorkspaceSummary, "id" | "change_cursor">,
+		ui: StatusUi,
+		options: StatusPollerOptions = {},
+	) {
+		this.controlPlane = controlPlane;
+		this.workspaceId = workspace.id;
+		this.cursor = workspace.change_cursor ?? 0;
+		this.ui = ui;
+		this.waitSeconds = options.waitSeconds ?? 30;
+		this.delay = options.delay ?? sleep;
+	}
+
+	start(): void {
+		if (!this.loop) this.loop = this.run();
+	}
+
+	pause(): void {
+		this.paused = true;
+		this.controller?.abort();
+	}
+
+	resume(): void {
+		if (!this.paused) return;
+		this.paused = false;
+		this.wake?.();
+	}
+
+	async stop(): Promise<void> {
+		this.stopped = true;
+		this.controller?.abort();
+		this.wake?.();
+		await this.loop;
+		this.ui.setStatus(STATUS_KEY, undefined);
+	}
+
+	private async run(): Promise<void> {
+		let backoffMs = 1_000;
+		while (!this.stopped) {
+			if (this.paused) {
+				await new Promise<void>((resolve) => {
+					this.wake = resolve;
+				});
+				continue;
+			}
+			this.controller = new AbortController();
+			try {
+				const change = await this.controlPlane.workspaces.change(
+					this.workspaceId,
+					this.cursor,
+					this.waitSeconds,
+					{ signal: this.controller.signal },
+				);
+				backoffMs = 1_000;
+				this.cursor = change.cursor;
+				this.lastText = statusText(change.workspace);
+				this.ui.setStatus(STATUS_KEY, this.lastText);
+				if (TERMINAL_WORKSPACE_STATES.has(change.workspace.state)) {
+					this.ui.notify(
+						`workspace ${change.workspace.id.slice(0, 8)} is ${change.workspace.state}`,
+						change.workspace.state === "succeeded" ? "info" : "warning",
+					);
+					return;
+				}
+			} catch {
+				if (this.stopped || this.paused) continue;
+				this.ui.setStatus(
+					STATUS_KEY,
+					`${this.lastText ?? `ws ${this.workspaceId.slice(0, 8)}`} · reconnecting`,
+				);
+				await this.delay(backoffMs);
+				backoffMs = Math.min(backoffMs * 2, 30_000);
+			}
+		}
+	}
+}