@dxos/plugin-thread 0.8.4-main.c1de068 → 0.8.4-main.c351d160a8

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

@@ -0,0 +1,392 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability, UndoMapping } from '@dxos/app-framework';
+import { sleep } from '@dxos/async';
+import { COMPANION_PREFIX } from '@dxos/app-toolkit';
+import { Obj, Ref, Relation } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { Operation, OperationResolver } from '@dxos/operation';
+import { DeckOperation } from '@dxos/plugin-deck/types';
+import { ObservabilityOperation } from '@dxos/plugin-observability/types';
+import { SpaceOperation } from '@dxos/plugin-space/types';
+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 }) {
+            if (isDefault) {
+              return;
+            }
+
+            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, {
+              companion: `${COMPANION_PREFIX}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,101 @@
+//
+// 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 '../../containers';
+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 { attendableId: string; subject: Channel.Channel } =>
+          typeof data.attendableId === 'string' && Obj.instanceOf(Channel.Channel, data.subject),
+        component: ({ data: { subject, attendableId }, role }) => (
+          <ChannelContainer role={role} subject={subject} attendableId={attendableId} />
+        ),
+      }),
+      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 { attendableId?: string; 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 attendableId={data.attendableId} 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/settings/index.ts

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

package/src/capabilities/settings/settings.ts

@@ -0,0 +1,34 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { createKvsStore } from '@dxos/effect';
+
+import { meta } from '../../meta';
+import { ThreadSettingsSchema } from '../../types';
+import { ThreadCapabilities } from '../../types/capabilities';
+
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const settingsAtom = createKvsStore({
+      key: meta.id,
+      schema: ThreadSettingsSchema,
+      defaultValue: () => ({}),
+    });
+
+    return [
+      // Expose atom directly for programmatic access.
+      Capability.contributes(ThreadCapabilities.Settings, settingsAtom),
+      // Contribute to common settings for UI discovery.
+      Capability.contributes(AppCapabilities.Settings, {
+        prefix: meta.id,
+        schema: ThreadSettingsSchema,
+        atom: settingsAtom,
+      }),
+    ];
+  }),
+);

package/src/capabilities/state/index.ts

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

package/src/capabilities/state/state.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+
+import { ThreadCapabilities, type ThreadState, type ViewStore } from '../../types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const stateAtom = Atom.make<ThreadState>({ toolbar: {}, drafts: {} }).pipe(Atom.keepAlive);
+    const viewStoreAtom = Atom.make<ViewStore>({}).pipe(Atom.keepAlive);
+
+    return [
+      Capability.contributes(ThreadCapabilities.State, stateAtom),
+      Capability.contributes(ThreadCapabilities.ViewState, viewStoreAtom),
+    ];
+  }),
+);

package/src/components/Call/Call.tsx

@@ -2,17 +2,19 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { type PropsWithChildren, type FC } from 'react';
+import { useAtomValue } from '@effect-atom/atom-react';
+import React, { type FC, type PropsWithChildren } from 'react';
 
-import { useCapability } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/ui';
 import { type ThemedClassName } from '@dxos/react-ui';
 
-import { Toolbar, type ToolbarProps } from './Toolbar';
-import { ThreadCapabilities } from '../../capabilities';
 import { useDebugMode } from '../../hooks';
+import { ThreadCapabilities } from '../../types';
 import { AudioStream } from '../Media';
 import { ParticipantGrid } from '../Participant';
 
+import { Toolbar, type ToolbarProps } from './Toolbar';
+
 //
 // Root
 //
@@ -33,8 +35,9 @@ type CallAudioProps = {};
 
 const CallAudio: FC<CallAudioProps> = () => {
   const call = useCapability(ThreadCapabilities.CallManager);
+  const audioTracksToPlay = useAtomValue(call.audioTracksToPlayAtom);
 
-  return <AudioStream tracks={call.audioTracksToPlay} />;
+  return <AudioStream tracks={audioTracksToPlay} />;
 };
 
 CallAudio.displayName = 'CallAudio';
@@ -50,10 +53,12 @@ type CallGridProps = {
 const CallGrid: FC<CallGridProps> = ({ fullscreen }) => {
   const debug = useDebugMode();
   const call = useCapability(ThreadCapabilities.CallManager);
+  const self = useAtomValue(call.selfAtom);
+  const users = useAtomValue(call.usersAtom);
 
   return (
     <div className='grid grow p-4 dark:bg-neutral-900'>
-      <ParticipantGrid self={call.self} users={call.users} debug={debug} fullscreen={fullscreen} />
+      <ParticipantGrid self={self} users={users} debug={debug} fullscreen={fullscreen} />
     </div>
   );
 };