@dxos/plugin-thread 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

package/src/calls/util/task-scheduling.ts

@@ -1,92 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-const DefaultBatchSizeLimit = 64;
-
-type Task<Value = unknown> = () => Promise<Value>;
-
-export class FIFOScheduler {
-  #schedulerChain: Promise<void>;
-
-  constructor() {
-    this.#schedulerChain = Promise.resolve();
-  }
-
-  schedule<T>(task: Task<T>): Promise<T> {
-    return new Promise((resolve, reject) => {
-      this.#schedulerChain = this.#schedulerChain.then(async () => {
-        try {
-          resolve(await task());
-        } catch (error: any) {
-          reject(error);
-        }
-      });
-    });
-  }
-}
-
-// TODO(mykola): Reconcile with @dxos/async task scheduling.
-export class BulkRequestDispatcher<RequestEntryParams, BulkResponse> {
-  #currentBatch: RequestEntryParams[];
-  #currentBulkResponse: Promise<BulkResponse> | null;
-  #batchSizeLimit: number;
-
-  constructor(batchSizeLimit: number = DefaultBatchSizeLimit) {
-    this.#currentBatch = [];
-    this.#currentBulkResponse = null;
-    this.#batchSizeLimit = batchSizeLimit;
-  }
-
-  /**
-   * Returns a bulk response promise.
-   * At the event loop iteration end, the accumulated entries will be dispatched as a bulk request.
-   */
-  doBulkRequest(
-    params: RequestEntryParams,
-    bulkRequestFunc: (bulkCopy: RequestEntryParams[]) => Promise<BulkResponse>,
-  ): Promise<BulkResponse> {
-    if (this.#currentBatch.length >= this.#batchSizeLimit) {
-      // If it reaches the batch size limit, we make another bulk request.
-      this.#currentBatch = [];
-      this.#currentBulkResponse = null;
-    }
-    this.#currentBatch.push(params);
-    if (this.#currentBulkResponse != null) {
-      return this.#currentBulkResponse;
-    }
-
-    // Save the current batch list reference in the function scope because this.#currentBatch could be reset
-    // if the batch limit is reached.
-    const batch = this.#currentBatch;
-    this.#currentBulkResponse = new Promise((resolve, reject) => {
-      //   script
-      //     |
-      //     V
-      // microtasks (Promise)
-      //     |
-      //     V
-      // macrotasks (setTimeout)
-      //
-      // macrotasks are run in the event loop iteration end, so we use that moment to make the bulkRequestFunc call.
-      setTimeout(() => {
-        // When the bulk request happens, the batch list and the response is reset to start another batch.
-        // Coming callers will wait for a new response promise.
-        this.#currentBulkResponse = null;
-
-        // We cut here to make the bulk request.
-        const batchCopy = batch.splice(0, batch.length);
-        bulkRequestFunc(batchCopy)
-          .then((result) => {
-            resolve(result);
-          })
-          .catch((err) => {
-            reject(err);
-          });
-      }, 0);
-    });
-
-    // This bulk response needs to be processed to extract the the result for the entry.
-    return this.#currentBulkResponse;
-  }
-}

package/src/calls-service.stories.tsx

@@ -1,216 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import '@dxos-theme';
-
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-
-import { scheduleTask, sleep } from '@dxos/async';
-import { Context } from '@dxos/context';
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
-import { Config, useConfig } from '@dxos/react-client';
-import { withClientProvider } from '@dxos/react-client/testing';
-import { Button } from '@dxos/react-ui';
-import { Json } from '@dxos/react-ui-syntax-highlighter';
-import { withLayout, withTheme } from '@dxos/storybook-utils';
-
-import video from '../testing/video.mp4?raw';
-
-import { CALLS_URL, CallsServicePeer, type TrackObject } from './calls';
-import { useInaudibleAudioStreamTrack, useVideoStreamTrack } from './hooks';
-
-const pushAndPullTrack = (mediaStreamTrack?: MediaStreamTrack) => {
-  const config = useConfig();
-  const callsConfig = {
-    iceServers: config.get('runtime.services.ice'),
-    apiBase: `${CALLS_URL}/api/calls`,
-  };
-  const peerPush = useMemo(() => new CallsServicePeer(callsConfig), []);
-  const peerPull = useMemo(() => new CallsServicePeer(callsConfig), []);
-  const [metrics, setMetrics] = useState<Record<string, any>>({});
-  const trackInfo = useRef<TrackObject | undefined>(undefined);
-  const pullCtx = useRef<Context | undefined>(undefined);
-  const [pulledTrack, setPulledTrack] = useState<MediaStreamTrack | undefined>(undefined);
-  const hadRun = useRef(false);
-
-  // Push/pull video stream track to cloudflare.
-  useEffect(() => {
-    if (hadRun.current || !mediaStreamTrack || !peerPush || !peerPull) {
-      log.info('not running', { hadRun: hadRun.current, mediaStreamTrack, peerPush, peerPull });
-      return;
-    }
-    hadRun.current = true;
-    const ctx = Context.default();
-    ctx.onDispose(() => {
-      log.info('disposing ctx', { ctx });
-    });
-    scheduleTask(
-      ctx,
-      async () => {
-        log.info('starting push/pull', { mediaStreamTrack });
-        await peerPush.open();
-        await peerPull.open();
-        ctx.onDispose(() => {
-          void peerPush.close();
-          void peerPull.close();
-        });
-
-        // Push track to cloudflare.
-        performance.mark('push:begin');
-        log.info('pushing track', { track: mediaStreamTrack });
-        trackInfo.current = await peerPush.pushTrack({ track: mediaStreamTrack });
-        performance.mark('push:end');
-        const pushTime = performance.measure('push', 'push:begin', 'push:end').duration;
-        log.info('successfully pushed track', { pushTime, trackInfo: trackInfo.current });
-        setMetrics((prev) => ({ ...prev, 'time to push track [ms]': Math.round(pushTime) }));
-
-        // Wait for cloudflare to process the track.
-        await sleep(1000);
-
-        // Pull track from cloudflare.
-        performance.mark('pullTrack:begin');
-        pullCtx.current = Context.default();
-        let retries = 0;
-        let pulledTrack: MediaStreamTrack | undefined;
-        while (!pulledTrack && retries < 3) {
-          retries++;
-          log.info('pulling track', {
-            trackData: { ...trackInfo.current!, mid: undefined },
-            retries,
-            pulledTrack,
-          });
-          pulledTrack = await peerPull.pullTrack({
-            trackData: { ...trackInfo.current!, mid: undefined },
-            ctx: pullCtx.current,
-          });
-          await sleep(200);
-        }
-        invariant(pulledTrack);
-        setPulledTrack(pulledTrack);
-        performance.mark('pullTrack:end');
-        const pullTime = performance.measure('pullTrack', 'pullTrack:begin', 'pullTrack:end').duration;
-        setMetrics((prev) => ({ ...prev, 'time to pull track [ms]': Math.round(pullTime) }));
-        log.info('successfully pulled track', { pullTime, pulledTrack });
-      },
-      1000,
-    );
-
-    return () => {
-      void ctx.dispose();
-    };
-  }, [mediaStreamTrack, peerPush, peerPull]);
-
-  const rePullTrack = useCallback(async () => {
-    performance.mark('rePullVideo:begin');
-    invariant(pulledTrack);
-    pulledTrack.stop();
-    await pullCtx.current!.dispose();
-    pullCtx.current = Context.default();
-    const newPulledTrack = await peerPull.pullTrack({
-      trackData: { ...trackInfo.current!, mid: undefined },
-      ctx: pullCtx.current,
-    });
-    invariant(newPulledTrack);
-    setPulledTrack(newPulledTrack);
-    performance.mark('rePullVideo:end');
-    const rePullTime = performance.measure('rePullVideo', 'rePullVideo:begin', 'rePullVideo:end').duration;
-    setMetrics((prev) => ({ ...prev, 'time to re-pull video [ms]': Math.round(rePullTime) }));
-  }, [peerPull, trackInfo.current, pullCtx.current, pulledTrack]);
-
-  return {
-    pulledTrack,
-    rePullTrack,
-    metrics,
-  };
-};
-
-const meta = {
-  title: 'plugins/plugin-thread/calls-service',
-  decorators: [
-    withClientProvider({
-      config: new Config({
-        runtime: {
-          services: {
-            iceProviders: [{ urls: 'https://edge.dxos.workers.dev/ice' }],
-          },
-        },
-      }),
-    }),
-    withTheme,
-    withLayout(),
-  ],
-  parameters: {
-    layout: 'centered',
-  },
-};
-
-export default meta;
-
-export const Default = {
-  render: ({ videoSrc }: { videoSrc: string }) => {
-    const pushVideoElement = useRef<HTMLVideoElement>(null);
-    const pullVideoElement = useRef<HTMLVideoElement>(null);
-    // Get video stream track.
-    const videoStreamTrack = useVideoStreamTrack(pushVideoElement, videoSrc);
-    const { pulledTrack, rePullTrack, metrics } = pushAndPullTrack(videoStreamTrack);
-    const hadRun = useRef(false);
-
-    // Push/pull video stream track to cloudflare.
-    useEffect(() => {
-      if (!pulledTrack || hadRun.current) {
-        return;
-      }
-      hadRun.current = true;
-      const ctx = Context.default();
-      scheduleTask(ctx, async () => {
-        pullVideoElement.current!.srcObject = new MediaStream([pulledTrack]);
-        await pullVideoElement.current!.play();
-      });
-
-      return () => {
-        void ctx.dispose();
-      };
-    }, [pulledTrack]);
-
-    return (
-      <div className='grid grid-rows-3 gap-4 items-center'>
-        <video ref={pushVideoElement} muted autoPlay loop />
-        <div className='flex flex-col gap-4'>
-          <video ref={pullVideoElement} muted />
-          <Button
-            disabled={
-              !(
-                pullVideoElement?.current?.srcObject instanceof MediaStream &&
-                pullVideoElement.current.srcObject.getTracks()[0]
-              )
-            }
-            onClick={rePullTrack}
-          >
-            Re-pull video
-          </Button>
-        </div>
-        <Json data={metrics} />
-      </div>
-    );
-  },
-  args: {
-    videoSrc: video,
-  },
-};
-
-export const InaudibleAudioStreamTrack = {
-  render: () => {
-    const audioStreamTrack = useInaudibleAudioStreamTrack();
-
-    const { rePullTrack, metrics } = pushAndPullTrack(audioStreamTrack);
-
-    return (
-      <div className='flex flex-col gap-4 items-center'>
-        <Json data={metrics} />
-        <Button onClick={rePullTrack}>Re-pull audio</Button>
-      </div>
-    );
-  },
-};

package/src/capabilities/call-manager.ts

@@ -1,20 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type PluginContext, contributes } from '@dxos/app-framework';
-import { ClientCapabilities } from '@dxos/plugin-client';
-
-import { CallManager } from '../calls';
-
-import { ThreadCapabilities } from './capabilities';
-
-export default async (context: PluginContext) => {
-  const client = context.getCapability(ClientCapabilities.Client);
-  const callManager = new CallManager(client);
-  await callManager.open();
-
-  return contributes(ThreadCapabilities.CallManager, callManager, () => {
-    void callManager.close();
-  });
-};

package/src/capabilities/capabilities.ts

@@ -1,33 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { defineCapability } from '@dxos/app-framework';
-import { type DeepReadonly } from '@dxos/util';
-
-import { type CallManager, type CallState, type MediaState } from '../calls';
-import { THREAD_PLUGIN } from '../meta';
-import { type ChannelType, type ThreadState, type ViewState } from '../types';
-
-export namespace ThreadCapabilities {
-  export const CallManager = defineCapability<CallManager>(`${THREAD_PLUGIN}/capability/call-manager`);
-
-  // TODO(burdon): Better way to define specific extensions for meeting companions.
-  // TODO(burdon): This brings in deps from ../calls; how should we manage/minimize explicit type exposure to other plugins?
-  // TODO(wittjosiah): These callbacks could be intents once we support broadcast.
-  export type CallProperties = {
-    onJoin: (state: { channel?: ChannelType; roomId?: string }) => Promise<void>;
-    onLeave: (roomId?: string) => Promise<void>;
-    onCallStateUpdated: (callState: CallState) => Promise<void>;
-    onMediaStateUpdated: ([mediaState, isSpeaking]: [MediaState, boolean]) => Promise<void>;
-  };
-  export const CallExtension = defineCapability<CallProperties>(`${THREAD_PLUGIN}/capability/call-extension`);
-
-  type GetViewState = (subjectId: string) => ViewState;
-  export const State = defineCapability<{ state: DeepReadonly<ThreadState>; getViewState: GetViewState }>(
-    `${THREAD_PLUGIN}/capability/state`,
-  );
-  export const MutableState = defineCapability<{ state: ThreadState; getViewState: GetViewState }>(
-    `${THREAD_PLUGIN}/capability/state`,
-  );
-}

package/src/capabilities/intent-resolver.ts

@@ -1,315 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Effect } from 'effect';
-
-import { Capabilities, type PluginContext, contributes, createIntent, createResolver } from '@dxos/app-framework';
-import { sleep } from '@dxos/async';
-import { Obj, Relation, Type } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
-import { ObservabilityAction } from '@dxos/plugin-observability/types';
-import { CollectionAction, SpaceAction } from '@dxos/plugin-space/types';
-import { Ref, fullyQualifiedId, getSpace } from '@dxos/react-client/echo';
-import { AnchoredTo, DataType } from '@dxos/schema';
-
-import { THREAD_PLUGIN } from '../meta';
-import { ChannelType, ThreadAction, ThreadType } from '../types';
-
-import { ThreadCapabilities } from './capabilities';
-
-export default (context: PluginContext) =>
-  contributes(Capabilities.IntentResolver, [
-    createResolver({
-      intent: ThreadAction.OnSpaceCreated,
-      resolve: ({ space, rootCollection }) =>
-        Effect.gen(function* () {
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const { object: collection } = yield* dispatch(
-            createIntent(CollectionAction.CreateQueryCollection, { typename: Type.getTypename(ChannelType) }),
-          );
-          rootCollection.objects.push(Ref.make(collection));
-
-          const { object: channel } = yield* dispatch(
-            createIntent(ThreadAction.CreateChannel, { name: 'General', spaceId: space.id }),
-          );
-          space.db.add(channel);
-        }),
-    }),
-    createResolver({
-      intent: ThreadAction.CreateChannel,
-      resolve: ({ name }) => ({
-        data: {
-          object: Obj.make(ChannelType, {
-            name,
-            defaultThread: Ref.make(Obj.make(ThreadType, { messages: [], status: 'active' })),
-            threads: [],
-          }),
-        },
-      }),
-    }),
-    createResolver({
-      intent: ThreadAction.CreateChannelThread,
-      resolve: ({ channel }) => {
-        const thread = Obj.make(ThreadType, { messages: [], status: 'active' });
-        channel.threads.push(Ref.make(thread));
-        return {
-          data: {
-            object: thread,
-          },
-        };
-      },
-    }),
-    // TODO(wittjosiah): Break this up into more composable pieces.
-    createResolver({
-      intent: ThreadAction.Create,
-      resolve: ({ name, anchor: _anchor, subject }) => {
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
-        const thread = Obj.make(ThreadType, { name, messages: [], status: 'staged' });
-        const anchor = Relation.make(AnchoredTo, {
-          [Relation.Source]: thread,
-          [Relation.Target]: subject,
-          anchor: _anchor,
-        });
-
-        const draft = state.drafts[subjectId];
-        if (draft) {
-          draft.push(anchor);
-        } else {
-          state.drafts[subjectId] = [anchor];
-        }
-
-        return {
-          intents: [
-            createIntent(ThreadAction.Select, { current: fullyQualifiedId(thread) }),
-            createIntent(DeckAction.ChangeCompanion, {
-              primary: subjectId,
-              companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`,
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.Select,
-      resolve: ({ current }) => {
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        state.current = current;
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.ToggleResolved,
-      resolve: ({ thread }) => {
-        if (thread.status === 'active' || thread.status === undefined) {
-          thread.status = 'resolved';
-        } else if (thread.status === 'resolved') {
-          thread.status = 'active';
-        }
-
-        const space = getSpace(thread);
-        invariant(space, 'Space not found');
-        const spaceId = space.id;
-
-        return {
-          intents: [
-            createIntent(ObservabilityAction.SendEvent, {
-              name: 'threads.toggle-resolved',
-              properties: {
-                spaceId,
-                threadId: thread.id,
-              },
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.Delete,
-      resolve: async ({ subject, anchor, thread: _thread }, undo) => {
-        const thread = _thread ?? (Relation.getSource(anchor) as ThreadType);
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
-        const draft = state.drafts[subjectId];
-        if (draft) {
-          // Check if we're deleting a draft; if so, remo ve it.
-          const index = draft.findIndex((a) => a.id === anchor.id);
-          if (index !== -1) {
-            draft.splice(index, 1);
-            return;
-          }
-        }
-
-        const space = getSpace(anchor);
-        if (!space) {
-          return;
-        }
-
-        if (!undo) {
-          // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
-          space.db.remove(anchor);
-          await sleep(100);
-          space.db.remove(thread);
-
-          return {
-            undoable: {
-              message: ['thread deleted label', { ns: THREAD_PLUGIN }],
-              data: { thread, anchor },
-            },
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                },
-              }),
-            ],
-          };
-        } else {
-          // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
-          space.db.add(thread);
-          await sleep(100);
-          space.db.add(anchor);
-
-          return {
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.undo-delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                },
-              }),
-            ],
-          };
-        }
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.AddMessage,
-      resolve: ({ anchor, subject, sender, text }) => {
-        const thread = Relation.getSource(anchor) as ThreadType;
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-        const intents = [];
-
-        const message = Obj.make(DataType.Message, {
-          created: new Date().toISOString(),
-          sender,
-          blocks: [{ _tag: 'text', text }],
-          // TODO(wittjosiah): Context based on attention.
-          // context: context ? Ref.make(context) : undefined,
-        });
-        thread.messages.push(Ref.make(message));
-
-        const draft = state.drafts[subjectId]?.find((a) => a.id === anchor.id);
-        if (draft) {
-          // Move draft to document.
-          thread.status = 'active';
-          // TODO(wittjosiah): This causes the thread to flash as it transitions from draft to db.
-          state.drafts[subjectId] = state.drafts[subjectId]?.filter((a) => a.id !== anchor.id);
-          intents.push(createIntent(SpaceAction.AddObject, { object: thread, target: space, hidden: true }));
-          intents.push(
-            createIntent(SpaceAction.AddRelation, {
-              space,
-              schema: AnchoredTo,
-              source: thread,
-              target: subject,
-              fields: { anchor: draft.anchor },
-            }),
-          );
-          intents.push(
-            createIntent(ObservabilityAction.SendEvent, {
-              name: 'threads.create',
-              properties: {
-                spaceId: space.id,
-                threadId: thread.id,
-              },
-            }),
-          );
-        }
-
-        intents.push(
-          createIntent(ObservabilityAction.SendEvent, {
-            name: 'threads.message.add',
-            properties: {
-              spaceId: space.id,
-              threadId: thread.id,
-              threadLength: thread.messages.length,
-              messageId: message.id,
-              messageLength: text.length,
-            },
-          }),
-        );
-
-        return { intents };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.DeleteMessage,
-      resolve: ({ subject, anchor, messageId, message, messageIndex }, undo) => {
-        const thread = Relation.getSource(anchor) as ThreadType;
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        if (!undo) {
-          const messageIndex = thread.messages.findIndex(Ref.hasObjectId(messageId));
-          const message = thread.messages[messageIndex]?.target;
-          if (!message) {
-            return;
-          }
-
-          if (messageIndex === 0 && thread.messages.length === 1) {
-            // If the message is the only message in the thread, delete the thread.
-            return {
-              intents: [createIntent(ThreadAction.Delete, { subject, anchor })],
-            };
-          } else {
-            thread.messages.splice(messageIndex, 1);
-          }
-
-          return {
-            undoable: {
-              message: ['message deleted label', { ns: THREAD_PLUGIN }],
-              data: { message, messageIndex },
-            },
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.message.delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                  messageId: message.id,
-                },
-              }),
-            ],
-          };
-        } else {
-          if (messageIndex === undefined || !message) {
-            return;
-          }
-
-          thread.messages.splice(messageIndex, 0, Ref.make(message));
-          return {
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.message.undo-delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                  messageId: message.id,
-                },
-              }),
-            ],
-          };
-        }
-      },
-    }),
-  ]);