@dxos/plugin-thread 0.8.4-main.3c1ae3b → 0.8.4-main.3eb6e50203

package/src/capabilities/markdown/markdown.ts

@@ -0,0 +1,83 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { EditorView } from '@codemirror/view';
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Obj } from '@dxos/echo';
+import { ATTENDABLE_PATH_SEPARATOR, DeckOperation } from '@dxos/plugin-deck/types';
+import { MarkdownCapabilities } from '@dxos/plugin-markdown';
+import { type EditorState, commentClickedEffect, commentsState, overlap } from '@dxos/ui-editor';
+
+import { threads } from '../../extensions';
+import { ThreadCapabilities } from '../../types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    // Get context for lazy capability access in callbacks.
+    const capabilities = yield* Capability.Service;
+
+    return Capability.contributes(MarkdownCapabilities.Extensions, [
+      ({ document: doc }) => {
+        const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
+        const registry = capabilities.get(Capabilities.AtomRegistry);
+        const stateAtom = capabilities.get(ThreadCapabilities.State);
+        return threads({ registry, stateAtom }, doc, invokePromise);
+      },
+      ({ document: doc }) => {
+        if (!doc) return [];
+        const registry = capabilities.get(Capabilities.AtomRegistry);
+        const stateAtom = capabilities.get(ThreadCapabilities.State);
+
+        return EditorView.updateListener.of((update) => {
+          if (update.docChanged || update.selectionSet) {
+            const objectId = Obj.getDXN(doc).toString();
+            const overlaps = selectionOverlapsComment(update.state);
+            const current = registry.get(stateAtom);
+            registry.set(stateAtom, {
+              ...current,
+              toolbar: { ...current.toolbar, [objectId]: overlaps },
+            });
+          }
+        });
+      },
+      ({ document: doc }) => {
+        if (!doc) return [];
+        const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
+        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 invokePromise(DeckOperation.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/operation-resolver/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const OperationResolver = Capability.lazy('OperationResolver', () => import('./operation-resolver'));

package/src/capabilities/operation-resolver/operation-resolver.ts

@@ -0,0 +1,400 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability, UndoMapping } from '@dxos/app-framework';
+import { sleep } from '@dxos/async';
+import { Obj, Relation, Type } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { OperationResolver } from '@dxos/operation';
+import { Operation } from '@dxos/operation';
+import { ATTENDABLE_PATH_SEPARATOR, DeckOperation } from '@dxos/plugin-deck/types';
+import { ObservabilityOperation } from '@dxos/plugin-observability/types';
+import { SpaceOperation } from '@dxos/plugin-space/types';
+import { Ref } from '@dxos/react-client/echo';
+import { Collection } from '@dxos/schema';
+import { AnchoredTo, Message, Thread } from '@dxos/types';
+
+import { meta } from '../../meta';
+import { Channel, ThreadCapabilities, ThreadOperation } from '../../types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return [
+      Capability.contributes(Capabilities.UndoMapping, [
+        UndoMapping.make({
+          operation: ThreadOperation.Delete,
+          inverse: ThreadOperation.Restore,
+          deriveContext: (_input, output) => {
+            // Return undefined if not undoable (e.g., draft deletion or no db).
+            if (!output.thread || !output.anchor) {
+              return;
+            }
+            return {
+              thread: output.thread,
+              anchor: output.anchor,
+            };
+          },
+          message: ['thread deleted label', { ns: meta.id }],
+        }),
+        UndoMapping.make({
+          operation: ThreadOperation.DeleteMessage,
+          inverse: ThreadOperation.RestoreMessage,
+          deriveContext: (input, output) => {
+            // Return undefined if not undoable (e.g., message not found or thread deleted).
+            if (!output.message || output.messageIndex === undefined) {
+              return;
+            }
+            return {
+              anchor: input.anchor,
+              message: output.message,
+              messageIndex: output.messageIndex,
+            };
+          },
+          message: ['message deleted label', { ns: meta.id }],
+        }),
+      ]),
+      Capability.contributes(Capabilities.OperationResolver, [
+        //
+        // CreateChannel
+        //
+        OperationResolver.make({
+          operation: ThreadOperation.CreateChannel,
+          handler: (input) =>
+            Effect.sync(() => ({
+              object: Channel.make({ name: input.name }),
+            })),
+        }),
+
+        //
+        // CreateChannelThread
+        //
+        OperationResolver.make({
+          operation: ThreadOperation.CreateChannelThread,
+          handler: (input) =>
+            Effect.sync(() => {
+              const thread = Thread.make({ status: 'active' });
+              const threadRef = Ref.make(thread);
+              Obj.change(input.channel, (c) => {
+                c.threads.push(threadRef);
+              });
+              return { object: thread };
+            }),
+        }),
+
+        //
+        // Select
+        //
+        OperationResolver.make({
+          operation: ThreadOperation.Select,
+          handler: Effect.fnUntraced(function* (input) {
+            const registry = yield* Capability.get(Capabilities.AtomRegistry);
+            const stateAtom = yield* Capability.get(ThreadCapabilities.State);
+            const current = registry.get(stateAtom);
+            registry.set(stateAtom, { ...current, current: input.current });
+          }),
+        }),
+
+        //
+        // ToggleResolved
+        //
+        OperationResolver.make({
+          operation: ThreadOperation.ToggleResolved,
+          handler: Effect.fnUntraced(function* (input) {
+            const thread = input.thread;
+
+            Obj.change(thread, (t) => {
+              if (t.status === 'active' || t.status === undefined) {
+                t.status = 'resolved';
+              } else if (t.status === 'resolved') {
+                t.status = 'active';
+              }
+            });
+
+            const db = Obj.getDatabase(thread);
+            invariant(db, 'Database not found');
+
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: 'threads.toggle-resolved',
+              properties: {
+                spaceId: db.spaceId,
+                threadId: thread.id,
+              },
+            });
+          }),
+        }),
+
+        //
+        // OnCreateSpace
+        //
+        OperationResolver.make({
+          operation: ThreadOperation.OnCreateSpace,
+          handler: Effect.fnUntraced(function* ({ space, isDefault, rootCollection }) {
+            if (isDefault) {
+              return;
+            }
+
+            const collection = Collection.makeManaged({ key: Type.getTypename(Channel.Channel) });
+            Obj.change(rootCollection, (c) => {
+              c.objects.push(Ref.make(collection));
+            });
+
+            const { object: channel } = yield* Operation.invoke(ThreadOperation.CreateChannel, {
+              name: 'General',
+              spaceId: space.id,
+            });
+            space.db.add(channel);
+          }),
+        }),
+
+        //
+        // Create
+        //
+        OperationResolver.make({
+          operation: ThreadOperation.Create,
+          handler: Effect.fnUntraced(function* ({ name, anchor: _anchor, subject }) {
+            const registry = yield* Capability.get(Capabilities.AtomRegistry);
+            const stateAtom = yield* Capability.get(ThreadCapabilities.State);
+            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 state = registry.get(stateAtom);
+            const existingDrafts = state.drafts[subjectId];
+            registry.set(stateAtom, {
+              ...state,
+              drafts: {
+                ...state.drafts,
+                [subjectId]: existingDrafts ? [...existingDrafts, anchor] : [anchor],
+              },
+            });
+
+            // Follow-up operations.
+            yield* Operation.invoke(ThreadOperation.Select, { current: Obj.getDXN(thread).toString() });
+            yield* Operation.invoke(DeckOperation.ChangeCompanion, {
+              primary: subjectId,
+              companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`,
+            });
+          }),
+        }),
+
+        //
+        // Delete
+        //
+        OperationResolver.make({
+          operation: ThreadOperation.Delete,
+          handler: Effect.fnUntraced(function* ({ subject, anchor, thread: _thread }) {
+            const registry = yield* Capability.get(Capabilities.AtomRegistry);
+            const stateAtom = yield* Capability.get(ThreadCapabilities.State);
+            const thread = _thread ?? (Relation.getSource(anchor) as Thread.Thread);
+            const subjectId = Obj.getDXN(subject).toString();
+            const state = registry.get(stateAtom);
+            const draft = state.drafts[subjectId];
+            if (draft) {
+              // Check if we're deleting a draft; if so, remove it.
+              const index = draft.findIndex((a: { id: string }) => a.id === anchor.id);
+              if (index !== -1) {
+                registry.set(stateAtom, {
+                  ...state,
+                  drafts: {
+                    ...state.drafts,
+                    [subjectId]: state.drafts[subjectId]?.filter((_, i) => i !== index),
+                  },
+                });
+                // Draft deletion is not undoable.
+                return {};
+              }
+            }
+
+            const db = Obj.getDatabase(thread);
+            if (!db) {
+              return {};
+            }
+
+            // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
+            db.remove(anchor);
+            yield* Effect.promise(() => sleep(100));
+            db.remove(thread);
+
+            // Schedule analytics event as followup (doesn't block return).
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: 'threads.delete',
+              properties: {
+                spaceId: db.spaceId,
+                threadId: thread.id,
+              },
+            });
+
+            // Return data needed for undo.
+            return { thread, anchor };
+          }),
+        }),
+
+        //
+        // AddMessage
+        //
+        OperationResolver.make({
+          operation: ThreadOperation.AddMessage,
+          handler: Effect.fnUntraced(function* ({ anchor, subject, sender, text }) {
+            const registry = yield* Capability.get(Capabilities.AtomRegistry);
+            const stateAtom = yield* Capability.get(ThreadCapabilities.State);
+            const thread = Relation.getSource(anchor) as Thread.Thread;
+            const subjectId = Obj.getDXN(subject).toString();
+            const db = Obj.getDatabase(subject);
+            invariant(db, 'Database not found');
+
+            const message = Obj.make(Message.Message, {
+              created: new Date().toISOString(),
+              sender,
+              blocks: [{ _tag: 'text', text }],
+            });
+            Obj.change(thread, (t) => {
+              t.messages.push(Ref.make(message));
+            });
+
+            const state = registry.get(stateAtom);
+            const draft = state.drafts[subjectId]?.find((a: { id: string }) => a.id === anchor.id);
+            if (draft) {
+              // Move draft to document.
+              Obj.change(thread, (t) => {
+                t.status = 'active';
+              });
+              registry.set(stateAtom, {
+                ...state,
+                drafts: {
+                  ...state.drafts,
+                  [subjectId]: state.drafts[subjectId]?.filter((a: { id: string }) => a.id !== anchor.id),
+                },
+              });
+              yield* Operation.invoke(SpaceOperation.AddObject, { object: thread, target: db, hidden: true });
+              yield* Operation.invoke(SpaceOperation.AddRelation, {
+                db,
+                schema: AnchoredTo.AnchoredTo,
+                source: thread,
+                target: subject,
+                fields: { anchor: draft.anchor },
+              });
+              yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+                name: 'threads.create',
+                properties: {
+                  spaceId: db.spaceId,
+                  threadId: thread.id,
+                },
+              });
+            }
+
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: 'threads.message.add',
+              properties: {
+                spaceId: db.spaceId,
+                threadId: thread.id,
+                threadLength: thread.messages.length,
+                messageId: message.id,
+                messageLength: text.length,
+              },
+            });
+          }),
+        }),
+
+        //
+        // DeleteMessage
+        //
+        OperationResolver.make({
+          operation: ThreadOperation.DeleteMessage,
+          handler: Effect.fnUntraced(function* ({ subject, anchor, messageId }) {
+            const thread = Relation.getSource(anchor) as Thread.Thread;
+            const db = Obj.getDatabase(subject);
+            invariant(db, 'Database not found');
+
+            const msgIndex = thread.messages.findIndex((ref) => ref.target?.id === messageId);
+            const msg = thread.messages[msgIndex]?.target;
+            if (!msg) {
+              return { messageIndex: -1 };
+            }
+
+            if (msgIndex === 0 && thread.messages.length === 1) {
+              // TODO(wittjosiah): This doesn't support restoring the thread.
+              yield* Operation.invoke(ThreadOperation.Delete, { subject, anchor });
+              return { messageIndex: -1 };
+            }
+
+            Obj.change(thread, (t) => {
+              t.messages.splice(msgIndex, 1);
+            });
+
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: 'threads.message.delete',
+              properties: {
+                spaceId: db.spaceId,
+                threadId: thread.id,
+                threadLength: thread.messages.length,
+                messageId,
+              },
+            });
+
+            // Return data needed for undo.
+            return { message: msg, messageIndex: msgIndex };
+          }),
+        }),
+
+        //
+        // Restore (inverse of Delete)
+        //
+        OperationResolver.make({
+          operation: ThreadOperation.Restore,
+          handler: Effect.fnUntraced(function* ({ thread, anchor }) {
+            const db = Obj.getDatabase(thread);
+            if (!db) {
+              return;
+            }
+
+            // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
+            db.add(thread);
+            yield* Effect.promise(() => sleep(100));
+            db.add(anchor);
+
+            // Schedule analytics event as followup (doesn't block return).
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: 'threads.undo-delete',
+              properties: {
+                spaceId: db.spaceId,
+                threadId: thread.id,
+              },
+            });
+          }),
+        }),
+
+        //
+        // RestoreMessage (inverse of DeleteMessage)
+        //
+        OperationResolver.make({
+          operation: ThreadOperation.RestoreMessage,
+          handler: Effect.fnUntraced(function* ({ anchor, message, messageIndex }) {
+            const thread = Relation.getSource(anchor) as Thread.Thread;
+            const db = Obj.getDatabase(thread);
+            invariant(db, 'Database not found');
+
+            Obj.change(thread, (t) => {
+              t.messages.splice(messageIndex, 0, Ref.make(message));
+            });
+
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: 'threads.message.undo-delete',
+              properties: {
+                spaceId: db.spaceId,
+                threadId: thread.id,
+                messageId: message.id,
+              },
+            });
+          }),
+        }),
+      ]),
+    ];
+  }),
+);

package/src/capabilities/react-root/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ReactRoot = Capability.lazy('ReactRoot', () => import('./react-root'));

package/src/capabilities/react-root/react-root.tsx

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

package/src/capabilities/react-surface/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));

package/src/capabilities/react-surface/react-surface.tsx

@@ -0,0 +1,98 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface, useCapability, useSettingsState } from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Obj, type Ref } from '@dxos/echo';
+import { getSpace } from '@dxos/react-client/echo';
+import { Thread } from '@dxos/types';
+
+import {
+  CallDebugPanel,
+  CallSidebar,
+  ChannelContainer,
+  ChatContainer,
+  ThreadCompanion,
+  ThreadSettings,
+} from '../../components';
+import { meta } from '../../meta';
+import { Channel, ThreadCapabilities, type ThreadSettingsProps } from '../../types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: `${meta.id}/channel`,
+        role: 'article',
+        filter: (data): data is { subject: Channel.Channel } => Obj.instanceOf(Channel.Channel, data.subject),
+        component: ({ data: { subject }, role }) => <ChannelContainer role={role} subject={subject} />,
+      }),
+      Surface.create({
+        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} />;
+        },
+      }),
+      Surface.create({
+        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} />;
+        },
+      }),
+      Surface.create({
+        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} />,
+      }),
+      Surface.create({
+        id: `${meta.id}/plugin-settings`,
+        role: 'article',
+        filter: (data): data is { subject: AppCapabilities.Settings } =>
+          AppCapabilities.isSettings(data.subject) && data.subject.prefix === meta.id,
+        component: ({ data: { subject } }) => {
+          const { settings, updateSettings } = useSettingsState<ThreadSettingsProps>(subject.atom);
+          return <ThreadSettings settings={settings} onSettingsChange={updateSettings} />;
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}/assistant`,
+        role: 'deck-companion--active-call',
+        component: () => <CallSidebar />,
+      }),
+      Surface.create({
+        id: `${meta.id}/devtools-overview`,
+        role: 'devtools-overview',
+        component: () => {
+          const call = useCapability(ThreadCapabilities.CallManager);
+          const state = useAtomValue(call.stateAtom);
+          return <CallDebugPanel state={state} />;
+        },
+      }),
+    ]),
+  ),
+);

package/src/capabilities/repair/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const Repair = Capability.lazy('Repair', () => import('./repair'));

package/src/capabilities/{repair.ts → repair/repair.ts}

@@ -2,22 +2,30 @@
 // Copyright 2025 DXOS.org
 //
 
-import { contributes } from '@dxos/app-framework';
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
 import { Obj, Ref, Type } from '@dxos/echo';
 import { SpaceCapabilities } from '@dxos/plugin-space';
 import { type Space } from '@dxos/react-client/echo';
 import { Collection } from '@dxos/schema';
 
-import { Channel } from '../types';
+import { Channel } from '../../types';
 
-export default () =>
-  contributes(SpaceCapabilities.Repair, async ({ space, isDefault }) => {
-    if (isDefault) {
-      return;
-    }
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(
+      SpaceCapabilities.Repair,
+      async ({ space, isDefault }: { space: Space; isDefault: boolean }) => {
+        if (isDefault) {
+          return;
+        }
 
-    await ensureSystemCollection(space);
-  });
+        await ensureSystemCollection(space);
+      },
+    ),
+  ),
+);
 
 /**
  * Ensure the root collection has a system collection for Channels.
@@ -36,5 +44,8 @@ const ensureSystemCollection = async (space: Space) => {
     return;
   }
 
-  rootCollection.objects.push(Ref.make(Collection.makeManaged({ key: Type.getTypename(Channel.Channel) })));
+  const channelCollectionRef = Ref.make(Collection.makeManaged({ key: Type.getTypename(Channel.Channel) }));
+  Obj.change(rootCollection, (c) => {
+    c.objects.push(channelCollectionRef);
+  });
 };