@dxos/plugin-thread 0.8.4-main.72ec0f3 → 0.8.4-main.937b3ca

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 { meta } from '../meta';
-import { type Channel, type ThreadState, type ViewState } from '../types';
-
-export namespace ThreadCapabilities {
-  export const CallManager = defineCapability<CallManager>(`${meta.id}/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?: Channel.Channel; 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>(`${meta.id}/capability/call-extension`);
-
-  type GetViewState = (subjectId: string) => ViewState;
-  export const State = defineCapability<{ state: DeepReadonly<ThreadState>; getViewState: GetViewState }>(
-    `${meta.id}/capability/state`,
-  );
-  export const MutableState = defineCapability<{ state: ThreadState; getViewState: GetViewState }>(
-    `${meta.id}/capability/state`,
-  );
-}

package/src/capabilities/intent-resolver.ts

@@ -1,311 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/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, getSpace } from '@dxos/react-client/echo';
-import { AnchoredTo, Message } from '@dxos/types';
-
-import { meta } from '../meta';
-import { Channel, Thread, ThreadAction } from '../types';
-
-import { ThreadCapabilities } from './capabilities';
-
-export default (context: PluginContext) =>
-  contributes(Capabilities.IntentResolver, [
-    createResolver({
-      intent: ThreadAction.onCreateSpace,
-      resolve: ({ space, rootCollection }) =>
-        Effect.gen(function* () {
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const { object: collection } = yield* dispatch(
-            createIntent(CollectionAction.CreateQueryCollection, { typename: Type.getTypename(Channel.Channel) }),
-          );
-          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: Channel.make({ name }),
-        },
-      }),
-    }),
-    createResolver({
-      intent: ThreadAction.CreateChannelThread,
-      resolve: ({ channel }) => {
-        const thread = Thread.make({ 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 = Obj.getDXN(subject).toString();
-        const thread = Thread.make({ name });
-        const anchor = Relation.make(AnchoredTo.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: Obj.getDXN(thread).toString() }),
-            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 Thread.Thread);
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = Obj.getDXN(subject).toString();
-        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: meta.id }],
-              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 Thread.Thread;
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = Obj.getDXN(subject).toString();
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        const message = Obj.make(Message.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 intents = [];
-        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.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 Thread.Thread;
-        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: meta.id }],
-              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,
-                },
-              }),
-            ],
-          };
-        }
-      },
-    }),
-  ]);

package/src/capabilities/markdown.ts

@@ -1,71 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { EditorView } from '@codemirror/view';
-
-import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
-import { Obj } from '@dxos/echo';
-import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
-import { MarkdownCapabilities } from '@dxos/plugin-markdown';
-import { type EditorState, commentClickedEffect, commentsState, overlap } from '@dxos/react-ui-editor';
-
-import { threads } from '../extensions';
-
-import { ThreadCapabilities } from './capabilities';
-
-export default (context: PluginContext) =>
-  contributes(MarkdownCapabilities.Extensions, [
-    ({ document: doc }) => {
-      const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-      const { state } = context.getCapability(ThreadCapabilities.MutableState);
-      return threads(state, doc, dispatch);
-    },
-    ({ document: doc }) => {
-      if (!doc) return [];
-      const { state } = context.getCapability(ThreadCapabilities.MutableState);
-
-      return EditorView.updateListener.of((update) => {
-        if (update.docChanged || update.selectionSet) {
-          state.toolbar[Obj.getDXN(doc).toString()] = selectionOverlapsComment(update.state);
-        }
-      });
-    },
-    ({ document: doc }) => {
-      if (!doc) return [];
-      const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-      const id = Obj.getDXN(doc).toString();
-
-      return EditorView.updateListener.of((update) => {
-        update.transactions.forEach((transaction) => {
-          transaction.effects.forEach(async (effect) => {
-            if (effect.is(commentClickedEffect)) {
-              void dispatch(
-                createIntent(DeckAction.ChangeCompanion, {
-                  primary: id,
-                  companion: `${id}${ATTENDABLE_PATH_SEPARATOR}comments`,
-                }),
-              );
-            }
-          });
-        });
-      });
-    },
-  ]);
-
-const selectionOverlapsComment = (state: EditorState): boolean => {
-  // May not be defined if thread plugin not installed.
-  const commentState = state.field(commentsState, false);
-  if (commentState === undefined) {
-    return false;
-  }
-
-  const { selection } = state;
-  for (const range of selection.ranges) {
-    if (commentState.comments.some(({ range: commentRange }) => overlap(commentRange, range))) {
-      return true;
-    }
-  }
-
-  return false;
-};

package/src/capabilities/react-root.tsx

@@ -1,17 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { Capabilities, contributes } from '@dxos/app-framework';
-
-import { Call } from '../components';
-import { meta } from '../meta';
-
-export default () => {
-  return contributes(Capabilities.ReactRoot, {
-    id: meta.id,
-    root: () => <Call.Audio />,
-  });
-};

package/src/capabilities/react-surface.tsx

@@ -1,90 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
-import { useCapability } from '@dxos/app-framework/react';
-import { Obj, type Ref } from '@dxos/echo';
-import { SettingsStore } from '@dxos/local-storage';
-import { getSpace } from '@dxos/react-client/echo';
-
-import {
-  CallDebugPanel,
-  CallSidebar,
-  ChannelContainer,
-  ChatContainer,
-  ThreadCompanion,
-  ThreadSettings,
-} from '../components';
-import { meta } from '../meta';
-import { Channel, Thread, type ThreadSettingsProps } from '../types';
-
-import { ThreadCapabilities } from './capabilities';
-
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: `${meta.id}/channel`,
-      role: 'article',
-      filter: (data): data is { subject: Channel.Channel } => Obj.instanceOf(Channel.Channel, data.subject),
-      component: ({ data: { subject }, role }) => <ChannelContainer channel={subject} role={role} />,
-    }),
-    createSurface({
-      id: `${meta.id}/chat-companion`,
-      role: 'article',
-      filter: (data): data is { companionTo: Channel.Channel; subject: 'chat' } =>
-        Obj.instanceOf(Channel.Channel, data.companionTo) && data.subject === 'chat',
-      component: ({ data: { companionTo: channel } }) => {
-        const space = getSpace(channel);
-        const thread = channel.defaultThread.target;
-        if (!space || !thread) {
-          return null;
-        }
-
-        return <ChatContainer thread={thread} space={space} />;
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/thread`,
-      role: 'article',
-      filter: (data): data is { subject: Thread.Thread } => Obj.instanceOf(Thread.Thread, data.subject),
-      component: ({ data: { subject } }) => {
-        const space = getSpace(subject);
-        if (!space || !subject) {
-          return null;
-        }
-
-        return <ChatContainer thread={subject} space={space} />;
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/comments`,
-      role: 'article',
-      filter: (data): data is { companionTo: { threads: Ref.Ref<Thread.Thread>[] } } =>
-        data.subject === 'comments' && Obj.isObject(data.companionTo),
-      // TODO(wittjosiah): This isn't scrolling properly in a plank.
-      component: ({ data }) => <ThreadCompanion subject={data.companionTo} />,
-    }),
-    createSurface({
-      id: `${meta.id}/plugin-settings`,
-      role: 'article',
-      filter: (data): data is { subject: SettingsStore<ThreadSettingsProps> } =>
-        data.subject instanceof SettingsStore && data.subject.prefix === meta.id,
-      component: ({ data: { subject } }) => <ThreadSettings settings={subject.value} />,
-    }),
-    createSurface({
-      id: `${meta.id}/assistant`,
-      role: 'deck-companion--active-call',
-      component: () => <CallSidebar />,
-    }),
-    createSurface({
-      id: `${meta.id}/devtools-overview`,
-      role: 'devtools-overview',
-      component: () => {
-        const call = useCapability(ThreadCapabilities.CallManager);
-        return <CallDebugPanel state={call.state} />;
-      },
-    }),
-  ]);

package/src/capabilities/settings.ts

@@ -1,19 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capabilities, contributes } from '@dxos/app-framework';
-import { live } from '@dxos/live-object';
-
-import { meta } from '../meta';
-import { type ThreadSettingsProps, ThreadSettingsSchema } from '../types';
-
-export default () => {
-  const settings = live<ThreadSettingsProps>({});
-
-  return contributes(Capabilities.Settings, {
-    prefix: meta.id,
-    schema: ThreadSettingsSchema,
-    value: settings,
-  });
-};

package/src/capabilities/state.ts

@@ -1,26 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { contributes } from '@dxos/app-framework';
-import { live } from '@dxos/live-object';
-
-import { type ThreadState, type ViewStore } from '../types';
-
-import { ThreadCapabilities } from './capabilities';
-
-const initialViewState = { showResolvedThreads: false };
-
-export default () => {
-  const state = live<ThreadState>({ toolbar: {}, drafts: {} });
-  const viewStore = live<ViewStore>({});
-
-  const getViewState = (subjectId: string) => {
-    if (!viewStore[subjectId]) {
-      viewStore[subjectId] = { ...initialViewState };
-    }
-    return viewStore[subjectId];
-  };
-
-  return contributes(ThreadCapabilities.State, { state, getViewState });
-};

package/src/types/Thread.ts

@@ -1,26 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-
-import { Obj, Type } from '@dxos/echo';
-import { Message } from '@dxos/types';
-
-export const ThreadStatus = Schema.Union(
-  Schema.Literal('staged'),
-  Schema.Literal('active'),
-  Schema.Literal('resolved'),
-);
-
-const _Thread = Schema.Struct({
-  name: Schema.String.pipe(Schema.optional),
-  status: ThreadStatus.pipe(Schema.optional),
-  messages: Schema.mutable(Schema.Array(Type.Ref(Message.Message))),
-}).pipe(Type.Obj({ typename: 'dxos.org/type/Thread', version: '0.1.0' }));
-export interface Thread extends Schema.Schema.Type<typeof _Thread> {}
-export interface ThreadEncoded extends Schema.Schema.Encoded<typeof _Thread> {}
-export const Thread: Schema.Schema<Thread, ThreadEncoded> = _Thread;
-
-export const make = ({ status = 'staged', messages = [], ...props }: Partial<Obj.MakeProps<typeof Thread>> = {}) =>
-  Obj.make(Thread, { status, messages, ...props });