@dxos/functions 0.5.3-main.59db342 → 0.5.3-main.61bbff4

package/src/testing/util.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Filter, type Space } from '@dxos/client/echo';
+import { invariant } from '@dxos/invariant';
+
+import { FunctionTrigger } from '../types';
+
+export const triggerWebhook = async (space: Space, uri: string) => {
+  const trigger = (
+    await space.db.query(Filter.schema(FunctionTrigger, (t: FunctionTrigger) => t.function === uri)).run()
+  ).objects[0];
+  invariant(trigger.spec.type === 'webhook');
+  void fetch(`http://localhost:${trigger.spec.port}`);
+};

package/src/trigger/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './trigger-registry';

package/src/trigger/trigger-registry.test.ts

@@ -0,0 +1,229 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import chai, { expect } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+
+import { sleep, Trigger, waitForCondition } from '@dxos/async';
+import { type Client } from '@dxos/client';
+import { type Space } from '@dxos/client/echo';
+import { TestBuilder } from '@dxos/client/testing';
+import { Context } from '@dxos/context';
+import { Filter } from '@dxos/echo-db';
+import { create } from '@dxos/echo-schema';
+import { describe, test } from '@dxos/test';
+import { range } from '@dxos/util';
+
+import { TriggerRegistry } from './trigger-registry';
+import { createInitializedClients, TestType, triggerWebhook } from '../testing';
+import { type FunctionManifest, FunctionTrigger } from '../types';
+
+const testManifest: FunctionManifest = {
+  triggers: [
+    {
+      function: 'example.com/function/webhook-test',
+      spec: {
+        type: 'webhook',
+        method: 'GET',
+      },
+    },
+    {
+      function: 'example.com/function/subscription-test',
+      spec: {
+        type: 'subscription',
+        filter: [{ type: TestType.typename }],
+      },
+    },
+  ],
+};
+
+chai.use(chaiAsPromised);
+
+describe('trigger registry', () => {
+  let ctx: Context;
+  let testBuilder: TestBuilder;
+  beforeEach(async () => {
+    ctx = new Context();
+    testBuilder = new TestBuilder();
+  });
+  afterEach(async () => {
+    await ctx.dispose();
+    await testBuilder.destroy();
+  });
+
+  describe('register', () => {
+    test('creates new triggers', async () => {
+      const client = (await createInitializedClients(testBuilder))[0];
+      const registry = createRegistry(client);
+      const space = await client.spaces.create();
+      await registry.register(space, testManifest);
+      const { objects } = await space.db.query(Filter.schema(FunctionTrigger)).run();
+      expect(objects.length).to.eq(testManifest.triggers?.length);
+      const expected = testManifest.triggers?.map((t) => t.function).sort();
+      expect(objects.map((o: FunctionTrigger) => o.function).sort()).to.deep.eq(expected);
+    });
+  });
+
+  describe('activate', () => {
+    test('invokes the provided callback', async () => {
+      const client = (await createInitializedClients(testBuilder))[0];
+      const space = await client.spaces.create();
+      const registry = createRegistry(client);
+      await registry.register(space, testManifest);
+      await registry.open(ctx);
+      await waitHasInactiveTriggers(registry, space);
+
+      const callbackInvoked = new Trigger();
+      const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
+      const webhookTrigger = allTriggers.find((t: FunctionTrigger) => t.spec.type === 'webhook')!;
+      await registry.activate({ space }, webhookTrigger, async () => {
+        callbackInvoked.wake();
+        return 200;
+      });
+
+      setTimeout(() => triggerWebhook(space, webhookTrigger.function));
+      await callbackInvoked.wait();
+    });
+
+    test('removes from inactive list', async () => {
+      const client = (await createInitializedClients(testBuilder))[0];
+      const space = await client.spaces.create();
+      const registry = createRegistry(client);
+      await registry.register(space, testManifest);
+      await registry.open(ctx);
+      await waitHasInactiveTriggers(registry, space);
+
+      const inactiveTrigger = registry.getInactiveTriggers(space)[0];
+      await registry.activate({ space }, inactiveTrigger, async () => 200);
+
+      const updatedInactiveList = registry.getInactiveTriggers(space);
+      expect(updatedInactiveList.find((t: FunctionTrigger) => t.function === inactiveTrigger.function)).to.be.undefined;
+    });
+  });
+
+  describe('deactivate', () => {
+    test('trigger object deletion deactivates a trigger', async () => {
+      const client = (await createInitializedClients(testBuilder))[0];
+      const space = await client.spaces.create();
+      const registry = createRegistry(client);
+      await registry.register(space, testManifest);
+      await registry.open(ctx);
+      await waitHasInactiveTriggers(registry, space);
+
+      const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
+      const echoTrigger = allTriggers.find((t: FunctionTrigger) => t.spec.type === 'subscription')!;
+      let count = 0;
+      await registry.activate({ space }, echoTrigger, async () => {
+        count++;
+        return 200;
+      });
+
+      space.db.add(create(TestType, { title: '1' }));
+      await sleep(20);
+      expect(count).to.eq(1);
+
+      space.db.remove(echoTrigger);
+
+      space.db.add(create(TestType, { title: '2' }));
+      await sleep(20);
+      expect(count).to.eq(1);
+    });
+
+    test('registry closing deactivates a trigger', async () => {
+      const client = (await createInitializedClients(testBuilder))[0];
+      const space = await client.spaces.create();
+      const registry = createRegistry(client);
+      await registry.register(space, testManifest);
+      await registry.open(ctx);
+      await waitHasInactiveTriggers(registry, space);
+
+      const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
+      const echoTrigger = allTriggers.find((t: FunctionTrigger) => t.spec.type === 'subscription')!;
+      let count = 0;
+      await registry.activate({ space }, echoTrigger, async () => {
+        count++;
+        return 200;
+      });
+
+      await registry.close();
+
+      space.db.add(create(TestType, { title: '1' }));
+      await sleep(20);
+      expect(count).to.eq(0);
+    });
+  });
+
+  describe('trigger events', () => {
+    test('event fired when all registered when opened', async () => {
+      const client = (await createInitializedClients(testBuilder))[0];
+      const registry = createRegistry(client);
+      const triggers = createTriggersInSpace(client.spaces.default, 3);
+
+      const triggersRegistered = new Trigger<FunctionTrigger[]>();
+      registry.registered.on((fn) => {
+        expect(fn.space.key.toHex()).to.eq(client.spaces.default.key.toHex());
+        triggersRegistered.wake(fn.triggers);
+      });
+      void registry.open(ctx);
+      const functions = await triggersRegistered.wait();
+      const expected = triggers.map((obj) => obj.id).sort();
+      expect(functions.map((fn) => fn.id).sort()).to.deep.eq(expected);
+    });
+
+    test('event fired when a new trigger is added', async () => {
+      const client = (await createInitializedClients(testBuilder))[0];
+      const registry = createRegistry(client);
+      const space = await client.spaces.create();
+
+      const triggerRegistered = new Trigger<FunctionTrigger>();
+      registry.registered.on((fn) => {
+        expect(fn.triggers.length).to.eq(1);
+        triggerRegistered.wake(fn.triggers[0]);
+      });
+      await registry.open(ctx);
+      await registry.register(space, { triggers: testManifest?.triggers?.slice(0, 1) });
+      const registered = await triggerRegistered.wait();
+      expect(registered.function).to.eq(testManifest.triggers![0].function);
+    });
+
+    test('event fired when a new trigger is removed', async () => {
+      const client = (await createInitializedClients(testBuilder))[0];
+      const registry = createRegistry(client);
+      const space = await client.spaces.create();
+      const triggers = createTriggersInSpace(space, 3);
+
+      const triggerLoaded = new Trigger();
+      registry.registered.on((fn) => triggerLoaded.wake());
+
+      const triggerRemoved = new Trigger<FunctionTrigger>();
+      registry.removed.on((fn) => {
+        expect(fn.triggers.length).to.eq(1);
+        triggerRemoved.wake(fn.triggers[0]);
+      });
+      await registry.register(space, testManifest);
+      await registry.open(ctx);
+      await triggerLoaded.wait();
+
+      space.db.remove(triggers[0]);
+      const removedTrigger = await triggerRemoved.wait();
+      expect(removedTrigger.id).to.eq(triggers[0].id);
+    });
+  });
+
+  const waitHasInactiveTriggers = async (registry: TriggerRegistry, space: Space) => {
+    await waitForCondition({ condition: () => registry.getInactiveTriggers(space).length > 0 });
+  };
+
+  const createRegistry = (client: Client) => {
+    const registry = new TriggerRegistry(client);
+    ctx.onDispose(() => registry.close());
+    return registry;
+  };
+
+  const createTriggersInSpace = (space: Space, count: number) => {
+    const triggers = range(count, () => create(FunctionTrigger, { ...testManifest.triggers![0] }));
+    triggers.forEach((def) => space.db.add(def));
+    return triggers;
+  };
+});

package/src/trigger/trigger-registry.ts

@@ -0,0 +1,176 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Event } from '@dxos/async';
+import { type Client } from '@dxos/client';
+import { create, Filter, type Space } from '@dxos/client/echo';
+import { Context, Resource } from '@dxos/context';
+import { invariant } from '@dxos/invariant';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { ComplexMap } from '@dxos/util';
+
+import { createSubscriptionTrigger, createTimerTrigger, createWebhookTrigger, createWebsocketTrigger } from './type';
+import { type FunctionManifest, FunctionTrigger, type FunctionTriggerType, type TriggerSpec } from '../types';
+
+type ResponseCode = number;
+
+export type TriggerCallback = (args: object) => Promise<ResponseCode>;
+
+export type TriggerContext = { space: Space };
+
+// TODO(burdon): Make object?
+export type TriggerFactory<Spec extends TriggerSpec, Options = any> = (
+  ctx: Context,
+  context: TriggerContext,
+  spec: Spec,
+  callback: TriggerCallback,
+  options?: Options,
+) => Promise<void>;
+
+export type TriggerHandlerMap = { [type in FunctionTriggerType]: TriggerFactory<any> };
+
+const triggerHandlers: TriggerHandlerMap = {
+  subscription: createSubscriptionTrigger,
+  timer: createTimerTrigger,
+  webhook: createWebhookTrigger,
+  websocket: createWebsocketTrigger,
+};
+
+export type TriggerEvent = {
+  space: Space;
+  triggers: FunctionTrigger[];
+};
+
+type RegisteredTrigger = {
+  activationCtx?: Context;
+  trigger: FunctionTrigger;
+};
+
+export class TriggerRegistry extends Resource {
+  private readonly _triggersBySpaceKey = new ComplexMap<PublicKey, RegisteredTrigger[]>(PublicKey.hash);
+
+  public readonly registered = new Event<TriggerEvent>();
+  public readonly removed = new Event<TriggerEvent>();
+
+  constructor(
+    private readonly _client: Client,
+    private readonly _options?: TriggerHandlerMap,
+  ) {
+    super();
+  }
+
+  public getActiveTriggers(space: Space): FunctionTrigger[] {
+    return this._getTriggers(space, (t) => t.activationCtx != null);
+  }
+
+  public getInactiveTriggers(space: Space): FunctionTrigger[] {
+    return this._getTriggers(space, (t) => t.activationCtx == null);
+  }
+
+  async activate(triggerCtx: TriggerContext, trigger: FunctionTrigger, callback: TriggerCallback): Promise<void> {
+    log('activate', { space: triggerCtx.space.key, trigger });
+    const activationCtx = new Context({ name: `trigger_${trigger.function}` });
+    this._ctx.onDispose(() => activationCtx.dispose());
+    const registeredTrigger = this._triggersBySpaceKey
+      .get(triggerCtx.space.key)
+      ?.find((reg) => reg.trigger.id === trigger.id);
+    invariant(registeredTrigger, `Trigger is not registered: ${trigger.function}`);
+    registeredTrigger.activationCtx = activationCtx;
+
+    try {
+      const options = this._options?.[trigger.spec.type];
+      await triggerHandlers[trigger.spec.type](activationCtx, triggerCtx, trigger.spec, callback, options);
+    } catch (err) {
+      delete registeredTrigger.activationCtx;
+      throw err;
+    }
+  }
+
+  /**
+   * Loads triggers from the manifest into the space.
+   */
+  public async register(space: Space, manifest: FunctionManifest): Promise<void> {
+    log('register', { space: space.key });
+    if (!manifest.triggers?.length) {
+      return;
+    }
+    if (!space.db.graph.runtimeSchemaRegistry.hasSchema(FunctionTrigger)) {
+      space.db.graph.runtimeSchemaRegistry.registerSchema(FunctionTrigger);
+    }
+
+    const reactiveObjects = manifest.triggers.map((template: Omit<FunctionTrigger, 'id'>) =>
+      create(FunctionTrigger, { ...template }),
+    );
+    reactiveObjects.forEach((obj) => space.db.add(obj));
+  }
+
+  protected override async _open(): Promise<void> {
+    const spaceListSubscription = this._client.spaces.subscribe(async (spaces) => {
+      for (const space of spaces) {
+        if (this._triggersBySpaceKey.has(space.key)) {
+          continue;
+        }
+
+        const registered: RegisteredTrigger[] = [];
+        this._triggersBySpaceKey.set(space.key, registered);
+        await space.waitUntilReady();
+        if (this._ctx.disposed) {
+          break;
+        }
+        const functionsSubscription = space.db.query(Filter.schema(FunctionTrigger)).subscribe(async (triggers) => {
+          await this._handleRemovedTriggers(space, triggers.objects, registered);
+          this._handleNewTriggers(space, triggers.objects, registered);
+        });
+
+        this._ctx.onDispose(functionsSubscription);
+      }
+    });
+
+    this._ctx.onDispose(() => spaceListSubscription.unsubscribe());
+  }
+
+  protected override async _close(_: Context): Promise<void> {
+    this._triggersBySpaceKey.clear();
+  }
+
+  private _handleNewTriggers(space: Space, allTriggers: FunctionTrigger[], registered: RegisteredTrigger[]) {
+    const newTriggers = allTriggers.filter((candidate) => {
+      return registered.find((reg) => reg.trigger.id === candidate.id) == null;
+    });
+
+    if (newTriggers.length > 0) {
+      const newRegisteredTriggers: RegisteredTrigger[] = newTriggers.map((trigger) => ({ trigger }));
+      registered.push(...newRegisteredTriggers);
+      log('registered new triggers', () => ({ spaceKey: space.key, functions: newTriggers.map((t) => t.function) }));
+      this.registered.emit({ space, triggers: newTriggers });
+    }
+  }
+
+  private async _handleRemovedTriggers(
+    space: Space,
+    allTriggers: FunctionTrigger[],
+    registered: RegisteredTrigger[],
+  ): Promise<void> {
+    const removed: FunctionTrigger[] = [];
+    for (let i = registered.length - 1; i >= 0; i--) {
+      const wasRemoved =
+        allTriggers.find((trigger: FunctionTrigger) => trigger.id === registered[i].trigger.id) == null;
+      if (wasRemoved) {
+        const unregistered = registered.splice(i, 1)[0];
+        await unregistered.activationCtx?.dispose();
+        removed.push(unregistered.trigger);
+      }
+    }
+
+    if (removed.length > 0) {
+      this.removed.emit({ space, triggers: removed });
+    }
+  }
+
+  private _getTriggers(space: Space, predicate: (trigger: RegisteredTrigger) => boolean): FunctionTrigger[] {
+    const allSpaceTriggers = this._triggersBySpaceKey.get(space.key) ?? [];
+    return allSpaceTriggers.filter(predicate).map((trigger) => trigger.trigger);
+  }
+}

package/src/trigger/type/index.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './subscription-trigger';
+export * from './timer-trigger';
+export * from './webhook-trigger';
+export * from './websocket-trigger';

package/src/trigger/type/subscription-trigger.ts

@@ -0,0 +1,73 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { TextV0Type } from '@braneframe/types';
+import { debounce, DeferredTask } from '@dxos/async';
+import { type Context } from '@dxos/context';
+import { createSubscription, Filter, getAutomergeObjectCore, type Query } from '@dxos/echo-db';
+import { log } from '@dxos/log';
+
+import type { SubscriptionTrigger } from '../../types';
+import { type TriggerCallback, type TriggerContext, type TriggerFactory } from '../trigger-registry';
+
+export const createSubscriptionTrigger: TriggerFactory<SubscriptionTrigger> = async (
+  ctx: Context,
+  triggerCtx: TriggerContext,
+  spec: SubscriptionTrigger,
+  callback: TriggerCallback,
+) => {
+  const objectIds = new Set<string>();
+  const task = new DeferredTask(ctx, async () => {
+    if (objectIds.size > 0) {
+      await callback({ objects: Array.from(objectIds) });
+      objectIds.clear();
+    }
+  });
+
+  // TODO(burdon): Don't fire initially?
+  // TODO(burdon): Create queue. Only allow one invocation per trigger at a time?
+  const subscriptions: (() => void)[] = [];
+  const subscription = createSubscription(({ added, updated }) => {
+    log.info('updated', { added: added.length, updated: updated.length });
+    for (const object of added) {
+      objectIds.add(object.id);
+    }
+    for (const object of updated) {
+      objectIds.add(object.id);
+    }
+
+    task.schedule();
+  });
+
+  subscriptions.push(() => subscription.unsubscribe());
+
+  // TODO(burdon): Disable trigger if keeps failing.
+  const { filter, options: { deep, delay } = {} } = spec;
+  const update = ({ objects }: Query) => {
+    subscription.update(objects);
+
+    // TODO(burdon): Hack to monitor changes to Document's text object.
+    if (deep) {
+      log.info('update', { objects: objects.length });
+      for (const object of objects) {
+        const content = object.content;
+        if (content instanceof TextV0Type) {
+          subscriptions.push(
+            getAutomergeObjectCore(content).updates.on(debounce(() => subscription.update([object]), 1_000)),
+          );
+        }
+      }
+    }
+  };
+
+  // TODO(burdon): Is Filter.or implemented?
+  // TODO(burdon): [Bug]: all callbacks are fired on the first mutation.
+  // TODO(burdon): [Bug]: not updated when document is deleted (either top or hierarchically).
+  const query = triggerCtx.space.db.query(Filter.or(filter.map(({ type, props }) => Filter.typename(type, props))));
+  subscriptions.push(query.subscribe(delay ? debounce(update, delay) : update));
+
+  ctx.onDispose(() => {
+    subscriptions.forEach((unsubscribe) => unsubscribe());
+  });
+};

package/src/trigger/type/timer-trigger.ts

@@ -0,0 +1,44 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { CronJob } from 'cron';
+
+import { DeferredTask } from '@dxos/async';
+import { type Context } from '@dxos/context';
+import { log } from '@dxos/log';
+
+import type { TimerTrigger } from '../../types';
+import { type TriggerCallback, type TriggerContext, type TriggerFactory } from '../trigger-registry';
+
+export const createTimerTrigger: TriggerFactory<TimerTrigger> = async (
+  ctx: Context,
+  triggerContext: TriggerContext,
+  spec: TimerTrigger,
+  callback: TriggerCallback,
+) => {
+  const task = new DeferredTask(ctx, async () => {
+    await callback({});
+  });
+
+  let last = 0;
+  let run = 0;
+  // https://www.npmjs.com/package/cron#constructor
+  const job = CronJob.from({
+    cronTime: spec.cron,
+    runOnInit: false,
+    onTick: () => {
+      // TODO(burdon): Check greater than 30s (use cron-parser).
+      const now = Date.now();
+      const delta = last ? now - last : 0;
+      last = now;
+
+      run++;
+      log.info('tick', { space: triggerContext.space.key.truncate(), count: run, delta });
+      task.schedule();
+    },
+  });
+
+  job.start();
+  ctx.onDispose(() => job.stop());
+};

package/src/trigger/type/webhook-trigger.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { getPort } from 'get-port-please';
+import http from 'node:http';
+
+import { type Context } from '@dxos/context';
+import { log } from '@dxos/log';
+
+import type { WebhookTrigger } from '../../types';
+import { type TriggerCallback, type TriggerContext, type TriggerFactory } from '../trigger-registry';
+
+export const createWebhookTrigger: TriggerFactory<WebhookTrigger> = async (
+  ctx: Context,
+  _: TriggerContext,
+  spec: WebhookTrigger,
+  callback: TriggerCallback,
+) => {
+  // TODO(burdon): Enable POST hook with payload.
+  const server = http.createServer(async (req, res) => {
+    if (req.method !== spec.method) {
+      res.statusCode = 405;
+      return res.end();
+    }
+    res.statusCode = await callback({});
+    res.end();
+  });
+
+  // TODO(burdon): Not used.
+  // const DEF_PORT_RANGE = { min: 7500, max: 7599 };
+  // const portRange = Object.assign({}, trigger.port, DEF_PORT_RANGE) as WebhookTrigger['port'];
+  const port = await getPort({
+    random: true,
+    // portRange: [portRange!.min, portRange!.max],
+  });
+
+  // TODO(burdon): Update trigger object with actual port.
+  server.listen(port, () => {
+    log.info('started webhook', { port });
+    spec.port = port;
+  });
+
+  ctx.onDispose(() => {
+    server.close();
+  });
+};

package/src/trigger/type/websocket-trigger.ts

@@ -0,0 +1,91 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import WebSocket from 'ws';
+
+import { sleep, Trigger } from '@dxos/async';
+import { type Context } from '@dxos/context';
+import { log } from '@dxos/log';
+
+import { type WebsocketTrigger } from '../../types';
+import { type TriggerCallback, type TriggerContext, type TriggerFactory } from '../trigger-registry';
+
+interface WebsocketTriggerOptions {
+  retryDelay: number;
+  maxAttempts: number;
+}
+
+/**
+ * Websocket.
+ * NOTE: The port must be unique, so the same hook cannot be used for multiple spaces.
+ */
+export const createWebsocketTrigger: TriggerFactory<WebsocketTrigger, WebsocketTriggerOptions> = async (
+  ctx: Context,
+  triggerCtx: TriggerContext,
+  spec: WebsocketTrigger,
+  callback: TriggerCallback,
+  options: WebsocketTriggerOptions = { retryDelay: 2, maxAttempts: 5 },
+) => {
+  const { url, init } = spec;
+
+  let ws: WebSocket;
+  for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
+    const open = new Trigger<boolean>();
+
+    ws = new WebSocket(url);
+    Object.assign(ws, {
+      onopen: () => {
+        log.info('opened', { url });
+        if (spec.init) {
+          ws.send(new TextEncoder().encode(JSON.stringify(init)));
+        }
+
+        open.wake(true);
+      },
+
+      onclose: (event) => {
+        log.info('closed', { url, code: event.code });
+        // Reconnect if server closes (e.g., CF restart).
+        // https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code
+        if (event.code === 1006) {
+          setTimeout(async () => {
+            log.info(`reconnecting in ${options.retryDelay}s...`, { url });
+            await createWebsocketTrigger(ctx, triggerCtx, spec, callback, options);
+          }, options.retryDelay * 1_000);
+        }
+
+        open.wake(false);
+      },
+
+      onerror: (event) => {
+        log.catch(event.error, { url });
+      },
+
+      onmessage: async (event) => {
+        try {
+          log.info('message');
+          const data = JSON.parse(new TextDecoder().decode(event.data as Uint8Array));
+          await callback({ data });
+        } catch (err) {
+          log.catch(err, { url });
+        }
+      },
+    } satisfies Partial<WebSocket>);
+
+    const isOpen = await open.wait();
+    if (isOpen) {
+      break;
+    } else {
+      const wait = Math.pow(attempt, 2) * options.retryDelay;
+      if (attempt < options.maxAttempts) {
+        log.warn(`failed to connect; trying again in ${wait}s`, { attempt });
+        await sleep(wait * 1_000);
+      }
+    }
+  }
+
+  ctx.onDispose(() => {
+    ws?.close();
+  });
+};